sqlglot.parser

   1from __future__ import annotations
   2
   3import logging
   4import typing as t
   5from collections import defaultdict
   6
   7from sqlglot import exp
   8from sqlglot.errors import ErrorLevel, ParseError, concat_messages, merge_errors
   9from sqlglot.helper import apply_index_offset, ensure_list, seq_get
  10from sqlglot.time import format_time
  11from sqlglot.tokens import Token, Tokenizer, TokenType
  12from sqlglot.trie import TrieResult, in_trie, new_trie
  13
  14if t.TYPE_CHECKING:
  15    from sqlglot._typing import E, Lit
  16    from sqlglot.dialects.dialect import Dialect, DialectType
  17
  18    T = t.TypeVar("T")
  19    TCeilFloor = t.TypeVar("TCeilFloor", exp.Ceil, exp.Floor)
  20
  21logger = logging.getLogger("sqlglot")
  22
  23OPTIONS_TYPE = t.Dict[str, t.Sequence[t.Union[t.Sequence[str], str]]]
  24
  25
  26def build_var_map(args: t.List) -> exp.StarMap | exp.VarMap:
  27    if len(args) == 1 and args[0].is_star:
  28        return exp.StarMap(this=args[0])
  29
  30    keys = []
  31    values = []
  32    for i in range(0, len(args), 2):
  33        keys.append(args[i])
  34        values.append(args[i + 1])
  35
  36    return exp.VarMap(keys=exp.array(*keys, copy=False), values=exp.array(*values, copy=False))
  37
  38
  39def build_like(args: t.List) -> exp.Escape | exp.Like:
  40    like = exp.Like(this=seq_get(args, 1), expression=seq_get(args, 0))
  41    return exp.Escape(this=like, expression=seq_get(args, 2)) if len(args) > 2 else like
  42
  43
  44def binary_range_parser(
  45    expr_type: t.Type[exp.Expression], reverse_args: bool = False
  46) -> t.Callable[[Parser, t.Optional[exp.Expression]], t.Optional[exp.Expression]]:
  47    def _parse_binary_range(
  48        self: Parser, this: t.Optional[exp.Expression]
  49    ) -> t.Optional[exp.Expression]:
  50        expression = self._parse_bitwise()
  51        if reverse_args:
  52            this, expression = expression, this
  53        return self._parse_escape(self.expression(expr_type, this=this, expression=expression))
  54
  55    return _parse_binary_range
  56
  57
  58def build_logarithm(args: t.List, dialect: Dialect) -> exp.Func:
  59    # Default argument order is base, expression
  60    this = seq_get(args, 0)
  61    expression = seq_get(args, 1)
  62
  63    if expression:
  64        if not dialect.LOG_BASE_FIRST:
  65            this, expression = expression, this
  66        return exp.Log(this=this, expression=expression)
  67
  68    return (exp.Ln if dialect.parser_class.LOG_DEFAULTS_TO_LN else exp.Log)(this=this)
  69
  70
  71def build_hex(args: t.List, dialect: Dialect) -> exp.Hex | exp.LowerHex:
  72    arg = seq_get(args, 0)
  73    return exp.LowerHex(this=arg) if dialect.HEX_LOWERCASE else exp.Hex(this=arg)
  74
  75
  76def build_lower(args: t.List) -> exp.Lower | exp.Hex:
  77    # LOWER(HEX(..)) can be simplified to LowerHex to simplify its transpilation
  78    arg = seq_get(args, 0)
  79    return exp.LowerHex(this=arg.this) if isinstance(arg, exp.Hex) else exp.Lower(this=arg)
  80
  81
  82def build_upper(args: t.List) -> exp.Upper | exp.Hex:
  83    # UPPER(HEX(..)) can be simplified to Hex to simplify its transpilation
  84    arg = seq_get(args, 0)
  85    return exp.Hex(this=arg.this) if isinstance(arg, exp.Hex) else exp.Upper(this=arg)
  86
  87
  88def build_extract_json_with_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
  89    def _builder(args: t.List, dialect: Dialect) -> E:
  90        expression = expr_type(
  91            this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
  92        )
  93        if len(args) > 2 and expr_type is exp.JSONExtract:
  94            expression.set("expressions", args[2:])
  95
  96        return expression
  97
  98    return _builder
  99
 100
 101def build_mod(args: t.List) -> exp.Mod:
 102    this = seq_get(args, 0)
 103    expression = seq_get(args, 1)
 104
 105    # Wrap the operands if they are binary nodes, e.g. MOD(a + 1, 7) -> (a + 1) % 7
 106    this = exp.Paren(this=this) if isinstance(this, exp.Binary) else this
 107    expression = exp.Paren(this=expression) if isinstance(expression, exp.Binary) else expression
 108
 109    return exp.Mod(this=this, expression=expression)
 110
 111
 112def build_pad(args: t.List, is_left: bool = True):
 113    return exp.Pad(
 114        this=seq_get(args, 0),
 115        expression=seq_get(args, 1),
 116        fill_pattern=seq_get(args, 2),
 117        is_left=is_left,
 118    )
 119
 120
 121def build_array_constructor(
 122    exp_class: t.Type[E], args: t.List, bracket_kind: TokenType, dialect: Dialect
 123) -> exp.Expression:
 124    array_exp = exp_class(expressions=args)
 125
 126    if exp_class == exp.Array and dialect.HAS_DISTINCT_ARRAY_CONSTRUCTORS:
 127        array_exp.set("bracket_notation", bracket_kind == TokenType.L_BRACKET)
 128
 129    return array_exp
 130
 131
 132def build_convert_timezone(
 133    args: t.List, default_source_tz: t.Optional[str] = None
 134) -> t.Union[exp.ConvertTimezone, exp.Anonymous]:
 135    if len(args) == 2:
 136        source_tz = exp.Literal.string(default_source_tz) if default_source_tz else None
 137        return exp.ConvertTimezone(
 138            source_tz=source_tz, target_tz=seq_get(args, 0), timestamp=seq_get(args, 1)
 139        )
 140
 141    return exp.ConvertTimezone.from_arg_list(args)
 142
 143
 144def build_trim(args: t.List, is_left: bool = True):
 145    return exp.Trim(
 146        this=seq_get(args, 0),
 147        expression=seq_get(args, 1),
 148        position="LEADING" if is_left else "TRAILING",
 149    )
 150
 151
 152def build_coalesce(args: t.List, is_nvl: t.Optional[bool] = None) -> exp.Coalesce:
 153    return exp.Coalesce(this=seq_get(args, 0), expressions=args[1:], is_nvl=is_nvl)
 154
 155
 156def build_locate_strposition(args: t.List):
 157    return exp.StrPosition(
 158        this=seq_get(args, 1),
 159        substr=seq_get(args, 0),
 160        position=seq_get(args, 2),
 161    )
 162
 163
 164class _Parser(type):
 165    def __new__(cls, clsname, bases, attrs):
 166        klass = super().__new__(cls, clsname, bases, attrs)
 167
 168        klass.SHOW_TRIE = new_trie(key.split(" ") for key in klass.SHOW_PARSERS)
 169        klass.SET_TRIE = new_trie(key.split(" ") for key in klass.SET_PARSERS)
 170
 171        return klass
 172
 173
 174class Parser(metaclass=_Parser):
 175    """
 176    Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.
 177
 178    Args:
 179        error_level: The desired error level.
 180            Default: ErrorLevel.IMMEDIATE
 181        error_message_context: The amount of context to capture from a query string when displaying
 182            the error message (in number of characters).
 183            Default: 100
 184        max_errors: Maximum number of error messages to include in a raised ParseError.
 185            This is only relevant if error_level is ErrorLevel.RAISE.
 186            Default: 3
 187    """
 188
 189    FUNCTIONS: t.Dict[str, t.Callable] = {
 190        **{name: func.from_arg_list for name, func in exp.FUNCTION_BY_NAME.items()},
 191        **dict.fromkeys(("COALESCE", "IFNULL", "NVL"), build_coalesce),
 192        "ARRAY": lambda args, dialect: exp.Array(expressions=args),
 193        "ARRAYAGG": lambda args, dialect: exp.ArrayAgg(
 194            this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
 195        ),
 196        "ARRAY_AGG": lambda args, dialect: exp.ArrayAgg(
 197            this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
 198        ),
 199        "CHAR": lambda args: exp.Chr(expressions=args),
 200        "CHR": lambda args: exp.Chr(expressions=args),
 201        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=True),
 202        "CONCAT": lambda args, dialect: exp.Concat(
 203            expressions=args,
 204            safe=not dialect.STRICT_STRING_CONCAT,
 205            coalesce=dialect.CONCAT_COALESCE,
 206        ),
 207        "CONCAT_WS": lambda args, dialect: exp.ConcatWs(
 208            expressions=args,
 209            safe=not dialect.STRICT_STRING_CONCAT,
 210            coalesce=dialect.CONCAT_COALESCE,
 211        ),
 212        "CONVERT_TIMEZONE": build_convert_timezone,
 213        "DATE_TO_DATE_STR": lambda args: exp.Cast(
 214            this=seq_get(args, 0),
 215            to=exp.DataType(this=exp.DataType.Type.TEXT),
 216        ),
 217        "GENERATE_DATE_ARRAY": lambda args: exp.GenerateDateArray(
 218            start=seq_get(args, 0),
 219            end=seq_get(args, 1),
 220            step=seq_get(args, 2) or exp.Interval(this=exp.Literal.number(1), unit=exp.var("DAY")),
 221        ),
 222        "GLOB": lambda args: exp.Glob(this=seq_get(args, 1), expression=seq_get(args, 0)),
 223        "HEX": build_hex,
 224        "JSON_EXTRACT": build_extract_json_with_path(exp.JSONExtract),
 225        "JSON_EXTRACT_SCALAR": build_extract_json_with_path(exp.JSONExtractScalar),
 226        "JSON_EXTRACT_PATH_TEXT": build_extract_json_with_path(exp.JSONExtractScalar),
 227        "LIKE": build_like,
 228        "LOG": build_logarithm,
 229        "LOG2": lambda args: exp.Log(this=exp.Literal.number(2), expression=seq_get(args, 0)),
 230        "LOG10": lambda args: exp.Log(this=exp.Literal.number(10), expression=seq_get(args, 0)),
 231        "LOWER": build_lower,
 232        "LPAD": lambda args: build_pad(args),
 233        "LEFTPAD": lambda args: build_pad(args),
 234        "LTRIM": lambda args: build_trim(args),
 235        "MOD": build_mod,
 236        "RIGHTPAD": lambda args: build_pad(args, is_left=False),
 237        "RPAD": lambda args: build_pad(args, is_left=False),
 238        "RTRIM": lambda args: build_trim(args, is_left=False),
 239        "SCOPE_RESOLUTION": lambda args: exp.ScopeResolution(expression=seq_get(args, 0))
 240        if len(args) != 2
 241        else exp.ScopeResolution(this=seq_get(args, 0), expression=seq_get(args, 1)),
 242        "STRPOS": exp.StrPosition.from_arg_list,
 243        "CHARINDEX": lambda args: build_locate_strposition(args),
 244        "INSTR": exp.StrPosition.from_arg_list,
 245        "LOCATE": lambda args: build_locate_strposition(args),
 246        "TIME_TO_TIME_STR": lambda args: exp.Cast(
 247            this=seq_get(args, 0),
 248            to=exp.DataType(this=exp.DataType.Type.TEXT),
 249        ),
 250        "TO_HEX": build_hex,
 251        "TS_OR_DS_TO_DATE_STR": lambda args: exp.Substring(
 252            this=exp.Cast(
 253                this=seq_get(args, 0),
 254                to=exp.DataType(this=exp.DataType.Type.TEXT),
 255            ),
 256            start=exp.Literal.number(1),
 257            length=exp.Literal.number(10),
 258        ),
 259        "UNNEST": lambda args: exp.Unnest(expressions=ensure_list(seq_get(args, 0))),
 260        "UPPER": build_upper,
 261        "VAR_MAP": build_var_map,
 262    }
 263
 264    NO_PAREN_FUNCTIONS = {
 265        TokenType.CURRENT_DATE: exp.CurrentDate,
 266        TokenType.CURRENT_DATETIME: exp.CurrentDate,
 267        TokenType.CURRENT_TIME: exp.CurrentTime,
 268        TokenType.CURRENT_TIMESTAMP: exp.CurrentTimestamp,
 269        TokenType.CURRENT_USER: exp.CurrentUser,
 270    }
 271
 272    STRUCT_TYPE_TOKENS = {
 273        TokenType.NESTED,
 274        TokenType.OBJECT,
 275        TokenType.STRUCT,
 276        TokenType.UNION,
 277    }
 278
 279    NESTED_TYPE_TOKENS = {
 280        TokenType.ARRAY,
 281        TokenType.LIST,
 282        TokenType.LOWCARDINALITY,
 283        TokenType.MAP,
 284        TokenType.NULLABLE,
 285        TokenType.RANGE,
 286        *STRUCT_TYPE_TOKENS,
 287    }
 288
 289    ENUM_TYPE_TOKENS = {
 290        TokenType.DYNAMIC,
 291        TokenType.ENUM,
 292        TokenType.ENUM8,
 293        TokenType.ENUM16,
 294    }
 295
 296    AGGREGATE_TYPE_TOKENS = {
 297        TokenType.AGGREGATEFUNCTION,
 298        TokenType.SIMPLEAGGREGATEFUNCTION,
 299    }
 300
 301    TYPE_TOKENS = {
 302        TokenType.BIT,
 303        TokenType.BOOLEAN,
 304        TokenType.TINYINT,
 305        TokenType.UTINYINT,
 306        TokenType.SMALLINT,
 307        TokenType.USMALLINT,
 308        TokenType.INT,
 309        TokenType.UINT,
 310        TokenType.BIGINT,
 311        TokenType.UBIGINT,
 312        TokenType.INT128,
 313        TokenType.UINT128,
 314        TokenType.INT256,
 315        TokenType.UINT256,
 316        TokenType.MEDIUMINT,
 317        TokenType.UMEDIUMINT,
 318        TokenType.FIXEDSTRING,
 319        TokenType.FLOAT,
 320        TokenType.DOUBLE,
 321        TokenType.CHAR,
 322        TokenType.NCHAR,
 323        TokenType.VARCHAR,
 324        TokenType.NVARCHAR,
 325        TokenType.BPCHAR,
 326        TokenType.TEXT,
 327        TokenType.MEDIUMTEXT,
 328        TokenType.LONGTEXT,
 329        TokenType.MEDIUMBLOB,
 330        TokenType.LONGBLOB,
 331        TokenType.BINARY,
 332        TokenType.VARBINARY,
 333        TokenType.JSON,
 334        TokenType.JSONB,
 335        TokenType.INTERVAL,
 336        TokenType.TINYBLOB,
 337        TokenType.TINYTEXT,
 338        TokenType.TIME,
 339        TokenType.TIMETZ,
 340        TokenType.TIMESTAMP,
 341        TokenType.TIMESTAMP_S,
 342        TokenType.TIMESTAMP_MS,
 343        TokenType.TIMESTAMP_NS,
 344        TokenType.TIMESTAMPTZ,
 345        TokenType.TIMESTAMPLTZ,
 346        TokenType.TIMESTAMPNTZ,
 347        TokenType.DATETIME,
 348        TokenType.DATETIME2,
 349        TokenType.DATETIME64,
 350        TokenType.SMALLDATETIME,
 351        TokenType.DATE,
 352        TokenType.DATE32,
 353        TokenType.INT4RANGE,
 354        TokenType.INT4MULTIRANGE,
 355        TokenType.INT8RANGE,
 356        TokenType.INT8MULTIRANGE,
 357        TokenType.NUMRANGE,
 358        TokenType.NUMMULTIRANGE,
 359        TokenType.TSRANGE,
 360        TokenType.TSMULTIRANGE,
 361        TokenType.TSTZRANGE,
 362        TokenType.TSTZMULTIRANGE,
 363        TokenType.DATERANGE,
 364        TokenType.DATEMULTIRANGE,
 365        TokenType.DECIMAL,
 366        TokenType.DECIMAL32,
 367        TokenType.DECIMAL64,
 368        TokenType.DECIMAL128,
 369        TokenType.DECIMAL256,
 370        TokenType.UDECIMAL,
 371        TokenType.BIGDECIMAL,
 372        TokenType.UUID,
 373        TokenType.GEOGRAPHY,
 374        TokenType.GEOMETRY,
 375        TokenType.POINT,
 376        TokenType.RING,
 377        TokenType.LINESTRING,
 378        TokenType.MULTILINESTRING,
 379        TokenType.POLYGON,
 380        TokenType.MULTIPOLYGON,
 381        TokenType.HLLSKETCH,
 382        TokenType.HSTORE,
 383        TokenType.PSEUDO_TYPE,
 384        TokenType.SUPER,
 385        TokenType.SERIAL,
 386        TokenType.SMALLSERIAL,
 387        TokenType.BIGSERIAL,
 388        TokenType.XML,
 389        TokenType.YEAR,
 390        TokenType.UNIQUEIDENTIFIER,
 391        TokenType.USERDEFINED,
 392        TokenType.MONEY,
 393        TokenType.SMALLMONEY,
 394        TokenType.ROWVERSION,
 395        TokenType.IMAGE,
 396        TokenType.VARIANT,
 397        TokenType.VECTOR,
 398        TokenType.OBJECT,
 399        TokenType.OBJECT_IDENTIFIER,
 400        TokenType.INET,
 401        TokenType.IPADDRESS,
 402        TokenType.IPPREFIX,
 403        TokenType.IPV4,
 404        TokenType.IPV6,
 405        TokenType.UNKNOWN,
 406        TokenType.NULL,
 407        TokenType.NAME,
 408        TokenType.TDIGEST,
 409        TokenType.DYNAMIC,
 410        *ENUM_TYPE_TOKENS,
 411        *NESTED_TYPE_TOKENS,
 412        *AGGREGATE_TYPE_TOKENS,
 413    }
 414
 415    SIGNED_TO_UNSIGNED_TYPE_TOKEN = {
 416        TokenType.BIGINT: TokenType.UBIGINT,
 417        TokenType.INT: TokenType.UINT,
 418        TokenType.MEDIUMINT: TokenType.UMEDIUMINT,
 419        TokenType.SMALLINT: TokenType.USMALLINT,
 420        TokenType.TINYINT: TokenType.UTINYINT,
 421        TokenType.DECIMAL: TokenType.UDECIMAL,
 422    }
 423
 424    SUBQUERY_PREDICATES = {
 425        TokenType.ANY: exp.Any,
 426        TokenType.ALL: exp.All,
 427        TokenType.EXISTS: exp.Exists,
 428        TokenType.SOME: exp.Any,
 429    }
 430
 431    RESERVED_TOKENS = {
 432        *Tokenizer.SINGLE_TOKENS.values(),
 433        TokenType.SELECT,
 434    } - {TokenType.IDENTIFIER}
 435
 436    DB_CREATABLES = {
 437        TokenType.DATABASE,
 438        TokenType.DICTIONARY,
 439        TokenType.MODEL,
 440        TokenType.NAMESPACE,
 441        TokenType.SCHEMA,
 442        TokenType.SEQUENCE,
 443        TokenType.SINK,
 444        TokenType.SOURCE,
 445        TokenType.STORAGE_INTEGRATION,
 446        TokenType.STREAMLIT,
 447        TokenType.TABLE,
 448        TokenType.TAG,
 449        TokenType.VIEW,
 450        TokenType.WAREHOUSE,
 451    }
 452
 453    CREATABLES = {
 454        TokenType.COLUMN,
 455        TokenType.CONSTRAINT,
 456        TokenType.FOREIGN_KEY,
 457        TokenType.FUNCTION,
 458        TokenType.INDEX,
 459        TokenType.PROCEDURE,
 460        *DB_CREATABLES,
 461    }
 462
 463    ALTERABLES = {
 464        TokenType.INDEX,
 465        TokenType.TABLE,
 466        TokenType.VIEW,
 467    }
 468
 469    # Tokens that can represent identifiers
 470    ID_VAR_TOKENS = {
 471        TokenType.ALL,
 472        TokenType.ATTACH,
 473        TokenType.VAR,
 474        TokenType.ANTI,
 475        TokenType.APPLY,
 476        TokenType.ASC,
 477        TokenType.ASOF,
 478        TokenType.AUTO_INCREMENT,
 479        TokenType.BEGIN,
 480        TokenType.BPCHAR,
 481        TokenType.CACHE,
 482        TokenType.CASE,
 483        TokenType.COLLATE,
 484        TokenType.COMMAND,
 485        TokenType.COMMENT,
 486        TokenType.COMMIT,
 487        TokenType.CONSTRAINT,
 488        TokenType.COPY,
 489        TokenType.CUBE,
 490        TokenType.CURRENT_SCHEMA,
 491        TokenType.DEFAULT,
 492        TokenType.DELETE,
 493        TokenType.DESC,
 494        TokenType.DESCRIBE,
 495        TokenType.DETACH,
 496        TokenType.DICTIONARY,
 497        TokenType.DIV,
 498        TokenType.END,
 499        TokenType.EXECUTE,
 500        TokenType.EXPORT,
 501        TokenType.ESCAPE,
 502        TokenType.FALSE,
 503        TokenType.FIRST,
 504        TokenType.FILTER,
 505        TokenType.FINAL,
 506        TokenType.FORMAT,
 507        TokenType.FULL,
 508        TokenType.IDENTIFIER,
 509        TokenType.IS,
 510        TokenType.ISNULL,
 511        TokenType.INTERVAL,
 512        TokenType.KEEP,
 513        TokenType.KILL,
 514        TokenType.LEFT,
 515        TokenType.LIMIT,
 516        TokenType.LOAD,
 517        TokenType.MERGE,
 518        TokenType.NATURAL,
 519        TokenType.NEXT,
 520        TokenType.OFFSET,
 521        TokenType.OPERATOR,
 522        TokenType.ORDINALITY,
 523        TokenType.OVERLAPS,
 524        TokenType.OVERWRITE,
 525        TokenType.PARTITION,
 526        TokenType.PERCENT,
 527        TokenType.PIVOT,
 528        TokenType.PRAGMA,
 529        TokenType.RANGE,
 530        TokenType.RECURSIVE,
 531        TokenType.REFERENCES,
 532        TokenType.REFRESH,
 533        TokenType.RENAME,
 534        TokenType.REPLACE,
 535        TokenType.RIGHT,
 536        TokenType.ROLLUP,
 537        TokenType.ROW,
 538        TokenType.ROWS,
 539        TokenType.SEMI,
 540        TokenType.SET,
 541        TokenType.SETTINGS,
 542        TokenType.SHOW,
 543        TokenType.TEMPORARY,
 544        TokenType.TOP,
 545        TokenType.TRUE,
 546        TokenType.TRUNCATE,
 547        TokenType.UNIQUE,
 548        TokenType.UNNEST,
 549        TokenType.UNPIVOT,
 550        TokenType.UPDATE,
 551        TokenType.USE,
 552        TokenType.VOLATILE,
 553        TokenType.WINDOW,
 554        *CREATABLES,
 555        *SUBQUERY_PREDICATES,
 556        *TYPE_TOKENS,
 557        *NO_PAREN_FUNCTIONS,
 558    }
 559    ID_VAR_TOKENS.remove(TokenType.UNION)
 560
 561    TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
 562        TokenType.ANTI,
 563        TokenType.APPLY,
 564        TokenType.ASOF,
 565        TokenType.FULL,
 566        TokenType.LEFT,
 567        TokenType.LOCK,
 568        TokenType.NATURAL,
 569        TokenType.RIGHT,
 570        TokenType.SEMI,
 571        TokenType.WINDOW,
 572    }
 573
 574    ALIAS_TOKENS = ID_VAR_TOKENS
 575
 576    ARRAY_CONSTRUCTORS = {
 577        "ARRAY": exp.Array,
 578        "LIST": exp.List,
 579    }
 580
 581    COMMENT_TABLE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.IS}
 582
 583    UPDATE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.SET}
 584
 585    TRIM_TYPES = {"LEADING", "TRAILING", "BOTH"}
 586
 587    FUNC_TOKENS = {
 588        TokenType.COLLATE,
 589        TokenType.COMMAND,
 590        TokenType.CURRENT_DATE,
 591        TokenType.CURRENT_DATETIME,
 592        TokenType.CURRENT_SCHEMA,
 593        TokenType.CURRENT_TIMESTAMP,
 594        TokenType.CURRENT_TIME,
 595        TokenType.CURRENT_USER,
 596        TokenType.FILTER,
 597        TokenType.FIRST,
 598        TokenType.FORMAT,
 599        TokenType.GLOB,
 600        TokenType.IDENTIFIER,
 601        TokenType.INDEX,
 602        TokenType.ISNULL,
 603        TokenType.ILIKE,
 604        TokenType.INSERT,
 605        TokenType.LIKE,
 606        TokenType.MERGE,
 607        TokenType.NEXT,
 608        TokenType.OFFSET,
 609        TokenType.PRIMARY_KEY,
 610        TokenType.RANGE,
 611        TokenType.REPLACE,
 612        TokenType.RLIKE,
 613        TokenType.ROW,
 614        TokenType.UNNEST,
 615        TokenType.VAR,
 616        TokenType.LEFT,
 617        TokenType.RIGHT,
 618        TokenType.SEQUENCE,
 619        TokenType.DATE,
 620        TokenType.DATETIME,
 621        TokenType.TABLE,
 622        TokenType.TIMESTAMP,
 623        TokenType.TIMESTAMPTZ,
 624        TokenType.TRUNCATE,
 625        TokenType.WINDOW,
 626        TokenType.XOR,
 627        *TYPE_TOKENS,
 628        *SUBQUERY_PREDICATES,
 629    }
 630
 631    CONJUNCTION: t.Dict[TokenType, t.Type[exp.Expression]] = {
 632        TokenType.AND: exp.And,
 633    }
 634
 635    ASSIGNMENT: t.Dict[TokenType, t.Type[exp.Expression]] = {
 636        TokenType.COLON_EQ: exp.PropertyEQ,
 637    }
 638
 639    DISJUNCTION: t.Dict[TokenType, t.Type[exp.Expression]] = {
 640        TokenType.OR: exp.Or,
 641    }
 642
 643    EQUALITY = {
 644        TokenType.EQ: exp.EQ,
 645        TokenType.NEQ: exp.NEQ,
 646        TokenType.NULLSAFE_EQ: exp.NullSafeEQ,
 647    }
 648
 649    COMPARISON = {
 650        TokenType.GT: exp.GT,
 651        TokenType.GTE: exp.GTE,
 652        TokenType.LT: exp.LT,
 653        TokenType.LTE: exp.LTE,
 654    }
 655
 656    BITWISE = {
 657        TokenType.AMP: exp.BitwiseAnd,
 658        TokenType.CARET: exp.BitwiseXor,
 659        TokenType.PIPE: exp.BitwiseOr,
 660    }
 661
 662    TERM = {
 663        TokenType.DASH: exp.Sub,
 664        TokenType.PLUS: exp.Add,
 665        TokenType.MOD: exp.Mod,
 666        TokenType.COLLATE: exp.Collate,
 667    }
 668
 669    FACTOR = {
 670        TokenType.DIV: exp.IntDiv,
 671        TokenType.LR_ARROW: exp.Distance,
 672        TokenType.SLASH: exp.Div,
 673        TokenType.STAR: exp.Mul,
 674    }
 675
 676    EXPONENT: t.Dict[TokenType, t.Type[exp.Expression]] = {}
 677
 678    TIMES = {
 679        TokenType.TIME,
 680        TokenType.TIMETZ,
 681    }
 682
 683    TIMESTAMPS = {
 684        TokenType.TIMESTAMP,
 685        TokenType.TIMESTAMPTZ,
 686        TokenType.TIMESTAMPLTZ,
 687        *TIMES,
 688    }
 689
 690    SET_OPERATIONS = {
 691        TokenType.UNION,
 692        TokenType.INTERSECT,
 693        TokenType.EXCEPT,
 694    }
 695
 696    JOIN_METHODS = {
 697        TokenType.ASOF,
 698        TokenType.NATURAL,
 699        TokenType.POSITIONAL,
 700    }
 701
 702    JOIN_SIDES = {
 703        TokenType.LEFT,
 704        TokenType.RIGHT,
 705        TokenType.FULL,
 706    }
 707
 708    JOIN_KINDS = {
 709        TokenType.ANTI,
 710        TokenType.CROSS,
 711        TokenType.INNER,
 712        TokenType.OUTER,
 713        TokenType.SEMI,
 714        TokenType.STRAIGHT_JOIN,
 715    }
 716
 717    JOIN_HINTS: t.Set[str] = set()
 718
 719    LAMBDAS = {
 720        TokenType.ARROW: lambda self, expressions: self.expression(
 721            exp.Lambda,
 722            this=self._replace_lambda(
 723                self._parse_assignment(),
 724                expressions,
 725            ),
 726            expressions=expressions,
 727        ),
 728        TokenType.FARROW: lambda self, expressions: self.expression(
 729            exp.Kwarg,
 730            this=exp.var(expressions[0].name),
 731            expression=self._parse_assignment(),
 732        ),
 733    }
 734
 735    COLUMN_OPERATORS = {
 736        TokenType.DOT: None,
 737        TokenType.DCOLON: lambda self, this, to: self.expression(
 738            exp.Cast if self.STRICT_CAST else exp.TryCast,
 739            this=this,
 740            to=to,
 741        ),
 742        TokenType.ARROW: lambda self, this, path: self.expression(
 743            exp.JSONExtract,
 744            this=this,
 745            expression=self.dialect.to_json_path(path),
 746            only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
 747        ),
 748        TokenType.DARROW: lambda self, this, path: self.expression(
 749            exp.JSONExtractScalar,
 750            this=this,
 751            expression=self.dialect.to_json_path(path),
 752            only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
 753        ),
 754        TokenType.HASH_ARROW: lambda self, this, path: self.expression(
 755            exp.JSONBExtract,
 756            this=this,
 757            expression=path,
 758        ),
 759        TokenType.DHASH_ARROW: lambda self, this, path: self.expression(
 760            exp.JSONBExtractScalar,
 761            this=this,
 762            expression=path,
 763        ),
 764        TokenType.PLACEHOLDER: lambda self, this, key: self.expression(
 765            exp.JSONBContains,
 766            this=this,
 767            expression=key,
 768        ),
 769    }
 770
 771    EXPRESSION_PARSERS = {
 772        exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
 773        exp.Column: lambda self: self._parse_column(),
 774        exp.Condition: lambda self: self._parse_assignment(),
 775        exp.DataType: lambda self: self._parse_types(allow_identifiers=False, schema=True),
 776        exp.Expression: lambda self: self._parse_expression(),
 777        exp.From: lambda self: self._parse_from(joins=True),
 778        exp.Group: lambda self: self._parse_group(),
 779        exp.Having: lambda self: self._parse_having(),
 780        exp.Hint: lambda self: self._parse_hint_body(),
 781        exp.Identifier: lambda self: self._parse_id_var(),
 782        exp.Join: lambda self: self._parse_join(),
 783        exp.Lambda: lambda self: self._parse_lambda(),
 784        exp.Lateral: lambda self: self._parse_lateral(),
 785        exp.Limit: lambda self: self._parse_limit(),
 786        exp.Offset: lambda self: self._parse_offset(),
 787        exp.Order: lambda self: self._parse_order(),
 788        exp.Ordered: lambda self: self._parse_ordered(),
 789        exp.Properties: lambda self: self._parse_properties(),
 790        exp.Qualify: lambda self: self._parse_qualify(),
 791        exp.Returning: lambda self: self._parse_returning(),
 792        exp.Select: lambda self: self._parse_select(),
 793        exp.Sort: lambda self: self._parse_sort(exp.Sort, TokenType.SORT_BY),
 794        exp.Table: lambda self: self._parse_table_parts(),
 795        exp.TableAlias: lambda self: self._parse_table_alias(),
 796        exp.Tuple: lambda self: self._parse_value(),
 797        exp.Whens: lambda self: self._parse_when_matched(),
 798        exp.Where: lambda self: self._parse_where(),
 799        exp.Window: lambda self: self._parse_named_window(),
 800        exp.With: lambda self: self._parse_with(),
 801        "JOIN_TYPE": lambda self: self._parse_join_parts(),
 802    }
 803
 804    STATEMENT_PARSERS = {
 805        TokenType.ALTER: lambda self: self._parse_alter(),
 806        TokenType.ANALYZE: lambda self: self._parse_analyze(),
 807        TokenType.BEGIN: lambda self: self._parse_transaction(),
 808        TokenType.CACHE: lambda self: self._parse_cache(),
 809        TokenType.COMMENT: lambda self: self._parse_comment(),
 810        TokenType.COMMIT: lambda self: self._parse_commit_or_rollback(),
 811        TokenType.COPY: lambda self: self._parse_copy(),
 812        TokenType.CREATE: lambda self: self._parse_create(),
 813        TokenType.DELETE: lambda self: self._parse_delete(),
 814        TokenType.DESC: lambda self: self._parse_describe(),
 815        TokenType.DESCRIBE: lambda self: self._parse_describe(),
 816        TokenType.DROP: lambda self: self._parse_drop(),
 817        TokenType.GRANT: lambda self: self._parse_grant(),
 818        TokenType.INSERT: lambda self: self._parse_insert(),
 819        TokenType.KILL: lambda self: self._parse_kill(),
 820        TokenType.LOAD: lambda self: self._parse_load(),
 821        TokenType.MERGE: lambda self: self._parse_merge(),
 822        TokenType.PIVOT: lambda self: self._parse_simplified_pivot(),
 823        TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()),
 824        TokenType.REFRESH: lambda self: self._parse_refresh(),
 825        TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(),
 826        TokenType.SET: lambda self: self._parse_set(),
 827        TokenType.TRUNCATE: lambda self: self._parse_truncate_table(),
 828        TokenType.UNCACHE: lambda self: self._parse_uncache(),
 829        TokenType.UNPIVOT: lambda self: self._parse_simplified_pivot(is_unpivot=True),
 830        TokenType.UPDATE: lambda self: self._parse_update(),
 831        TokenType.USE: lambda self: self.expression(
 832            exp.Use,
 833            kind=self._parse_var_from_options(self.USABLES, raise_unmatched=False),
 834            this=self._parse_table(schema=False),
 835        ),
 836        TokenType.SEMICOLON: lambda self: exp.Semicolon(),
 837    }
 838
 839    UNARY_PARSERS = {
 840        TokenType.PLUS: lambda self: self._parse_unary(),  # Unary + is handled as a no-op
 841        TokenType.NOT: lambda self: self.expression(exp.Not, this=self._parse_equality()),
 842        TokenType.TILDA: lambda self: self.expression(exp.BitwiseNot, this=self._parse_unary()),
 843        TokenType.DASH: lambda self: self.expression(exp.Neg, this=self._parse_unary()),
 844        TokenType.PIPE_SLASH: lambda self: self.expression(exp.Sqrt, this=self._parse_unary()),
 845        TokenType.DPIPE_SLASH: lambda self: self.expression(exp.Cbrt, this=self._parse_unary()),
 846    }
 847
 848    STRING_PARSERS = {
 849        TokenType.HEREDOC_STRING: lambda self, token: self.expression(
 850            exp.RawString, this=token.text
 851        ),
 852        TokenType.NATIONAL_STRING: lambda self, token: self.expression(
 853            exp.National, this=token.text
 854        ),
 855        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, this=token.text),
 856        TokenType.STRING: lambda self, token: self.expression(
 857            exp.Literal, this=token.text, is_string=True
 858        ),
 859        TokenType.UNICODE_STRING: lambda self, token: self.expression(
 860            exp.UnicodeString,
 861            this=token.text,
 862            escape=self._match_text_seq("UESCAPE") and self._parse_string(),
 863        ),
 864    }
 865
 866    NUMERIC_PARSERS = {
 867        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, this=token.text),
 868        TokenType.BYTE_STRING: lambda self, token: self.expression(exp.ByteString, this=token.text),
 869        TokenType.HEX_STRING: lambda self, token: self.expression(exp.HexString, this=token.text),
 870        TokenType.NUMBER: lambda self, token: self.expression(
 871            exp.Literal, this=token.text, is_string=False
 872        ),
 873    }
 874
 875    PRIMARY_PARSERS = {
 876        **STRING_PARSERS,
 877        **NUMERIC_PARSERS,
 878        TokenType.INTRODUCER: lambda self, token: self._parse_introducer(token),
 879        TokenType.NULL: lambda self, _: self.expression(exp.Null),
 880        TokenType.TRUE: lambda self, _: self.expression(exp.Boolean, this=True),
 881        TokenType.FALSE: lambda self, _: self.expression(exp.Boolean, this=False),
 882        TokenType.SESSION_PARAMETER: lambda self, _: self._parse_session_parameter(),
 883        TokenType.STAR: lambda self, _: self._parse_star_ops(),
 884    }
 885
 886    PLACEHOLDER_PARSERS = {
 887        TokenType.PLACEHOLDER: lambda self: self.expression(exp.Placeholder),
 888        TokenType.PARAMETER: lambda self: self._parse_parameter(),
 889        TokenType.COLON: lambda self: (
 890            self.expression(exp.Placeholder, this=self._prev.text)
 891            if self._match_set(self.ID_VAR_TOKENS)
 892            else None
 893        ),
 894    }
 895
 896    RANGE_PARSERS = {
 897        TokenType.AT_GT: binary_range_parser(exp.ArrayContainsAll),
 898        TokenType.BETWEEN: lambda self, this: self._parse_between(this),
 899        TokenType.GLOB: binary_range_parser(exp.Glob),
 900        TokenType.ILIKE: binary_range_parser(exp.ILike),
 901        TokenType.IN: lambda self, this: self._parse_in(this),
 902        TokenType.IRLIKE: binary_range_parser(exp.RegexpILike),
 903        TokenType.IS: lambda self, this: self._parse_is(this),
 904        TokenType.LIKE: binary_range_parser(exp.Like),
 905        TokenType.LT_AT: binary_range_parser(exp.ArrayContainsAll, reverse_args=True),
 906        TokenType.OVERLAPS: binary_range_parser(exp.Overlaps),
 907        TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
 908        TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
 909        TokenType.FOR: lambda self, this: self._parse_comprehension(this),
 910    }
 911
 912    PROPERTY_PARSERS: t.Dict[str, t.Callable] = {
 913        "ALLOWED_VALUES": lambda self: self.expression(
 914            exp.AllowedValuesProperty, expressions=self._parse_csv(self._parse_primary)
 915        ),
 916        "ALGORITHM": lambda self: self._parse_property_assignment(exp.AlgorithmProperty),
 917        "AUTO": lambda self: self._parse_auto_property(),
 918        "AUTO_INCREMENT": lambda self: self._parse_property_assignment(exp.AutoIncrementProperty),
 919        "BACKUP": lambda self: self.expression(
 920            exp.BackupProperty, this=self._parse_var(any_token=True)
 921        ),
 922        "BLOCKCOMPRESSION": lambda self: self._parse_blockcompression(),
 923        "CHARSET": lambda self, **kwargs: self._parse_character_set(**kwargs),
 924        "CHARACTER SET": lambda self, **kwargs: self._parse_character_set(**kwargs),
 925        "CHECKSUM": lambda self: self._parse_checksum(),
 926        "CLUSTER BY": lambda self: self._parse_cluster(),
 927        "CLUSTERED": lambda self: self._parse_clustered_by(),
 928        "COLLATE": lambda self, **kwargs: self._parse_property_assignment(
 929            exp.CollateProperty, **kwargs
 930        ),
 931        "COMMENT": lambda self: self._parse_property_assignment(exp.SchemaCommentProperty),
 932        "CONTAINS": lambda self: self._parse_contains_property(),
 933        "COPY": lambda self: self._parse_copy_property(),
 934        "DATABLOCKSIZE": lambda self, **kwargs: self._parse_datablocksize(**kwargs),
 935        "DATA_DELETION": lambda self: self._parse_data_deletion_property(),
 936        "DEFINER": lambda self: self._parse_definer(),
 937        "DETERMINISTIC": lambda self: self.expression(
 938            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
 939        ),
 940        "DISTRIBUTED": lambda self: self._parse_distributed_property(),
 941        "DUPLICATE": lambda self: self._parse_composite_key_property(exp.DuplicateKeyProperty),
 942        "DYNAMIC": lambda self: self.expression(exp.DynamicProperty),
 943        "DISTKEY": lambda self: self._parse_distkey(),
 944        "DISTSTYLE": lambda self: self._parse_property_assignment(exp.DistStyleProperty),
 945        "EMPTY": lambda self: self.expression(exp.EmptyProperty),
 946        "ENGINE": lambda self: self._parse_property_assignment(exp.EngineProperty),
 947        "EXECUTE": lambda self: self._parse_property_assignment(exp.ExecuteAsProperty),
 948        "EXTERNAL": lambda self: self.expression(exp.ExternalProperty),
 949        "FALLBACK": lambda self, **kwargs: self._parse_fallback(**kwargs),
 950        "FORMAT": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
 951        "FREESPACE": lambda self: self._parse_freespace(),
 952        "GLOBAL": lambda self: self.expression(exp.GlobalProperty),
 953        "HEAP": lambda self: self.expression(exp.HeapProperty),
 954        "ICEBERG": lambda self: self.expression(exp.IcebergProperty),
 955        "IMMUTABLE": lambda self: self.expression(
 956            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
 957        ),
 958        "INHERITS": lambda self: self.expression(
 959            exp.InheritsProperty, expressions=self._parse_wrapped_csv(self._parse_table)
 960        ),
 961        "INPUT": lambda self: self.expression(exp.InputModelProperty, this=self._parse_schema()),
 962        "JOURNAL": lambda self, **kwargs: self._parse_journal(**kwargs),
 963        "LANGUAGE": lambda self: self._parse_property_assignment(exp.LanguageProperty),
 964        "LAYOUT": lambda self: self._parse_dict_property(this="LAYOUT"),
 965        "LIFETIME": lambda self: self._parse_dict_range(this="LIFETIME"),
 966        "LIKE": lambda self: self._parse_create_like(),
 967        "LOCATION": lambda self: self._parse_property_assignment(exp.LocationProperty),
 968        "LOCK": lambda self: self._parse_locking(),
 969        "LOCKING": lambda self: self._parse_locking(),
 970        "LOG": lambda self, **kwargs: self._parse_log(**kwargs),
 971        "MATERIALIZED": lambda self: self.expression(exp.MaterializedProperty),
 972        "MERGEBLOCKRATIO": lambda self, **kwargs: self._parse_mergeblockratio(**kwargs),
 973        "MODIFIES": lambda self: self._parse_modifies_property(),
 974        "MULTISET": lambda self: self.expression(exp.SetProperty, multi=True),
 975        "NO": lambda self: self._parse_no_property(),
 976        "ON": lambda self: self._parse_on_property(),
 977        "ORDER BY": lambda self: self._parse_order(skip_order_token=True),
 978        "OUTPUT": lambda self: self.expression(exp.OutputModelProperty, this=self._parse_schema()),
 979        "PARTITION": lambda self: self._parse_partitioned_of(),
 980        "PARTITION BY": lambda self: self._parse_partitioned_by(),
 981        "PARTITIONED BY": lambda self: self._parse_partitioned_by(),
 982        "PARTITIONED_BY": lambda self: self._parse_partitioned_by(),
 983        "PRIMARY KEY": lambda self: self._parse_primary_key(in_props=True),
 984        "RANGE": lambda self: self._parse_dict_range(this="RANGE"),
 985        "READS": lambda self: self._parse_reads_property(),
 986        "REMOTE": lambda self: self._parse_remote_with_connection(),
 987        "RETURNS": lambda self: self._parse_returns(),
 988        "STRICT": lambda self: self.expression(exp.StrictProperty),
 989        "STREAMING": lambda self: self.expression(exp.StreamingTableProperty),
 990        "ROW": lambda self: self._parse_row(),
 991        "ROW_FORMAT": lambda self: self._parse_property_assignment(exp.RowFormatProperty),
 992        "SAMPLE": lambda self: self.expression(
 993            exp.SampleProperty, this=self._match_text_seq("BY") and self._parse_bitwise()
 994        ),
 995        "SECURE": lambda self: self.expression(exp.SecureProperty),
 996        "SECURITY": lambda self: self._parse_security(),
 997        "SET": lambda self: self.expression(exp.SetProperty, multi=False),
 998        "SETTINGS": lambda self: self._parse_settings_property(),
 999        "SHARING": lambda self: self._parse_property_assignment(exp.SharingProperty),
1000        "SORTKEY": lambda self: self._parse_sortkey(),
1001        "SOURCE": lambda self: self._parse_dict_property(this="SOURCE"),
1002        "STABLE": lambda self: self.expression(
1003            exp.StabilityProperty, this=exp.Literal.string("STABLE")
1004        ),
1005        "STORED": lambda self: self._parse_stored(),
1006        "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(),
1007        "TBLPROPERTIES": lambda self: self._parse_wrapped_properties(),
1008        "TEMP": lambda self: self.expression(exp.TemporaryProperty),
1009        "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty),
1010        "TO": lambda self: self._parse_to_table(),
1011        "TRANSIENT": lambda self: self.expression(exp.TransientProperty),
1012        "TRANSFORM": lambda self: self.expression(
1013            exp.TransformModelProperty, expressions=self._parse_wrapped_csv(self._parse_expression)
1014        ),
1015        "TTL": lambda self: self._parse_ttl(),
1016        "USING": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
1017        "UNLOGGED": lambda self: self.expression(exp.UnloggedProperty),
1018        "VOLATILE": lambda self: self._parse_volatile_property(),
1019        "WITH": lambda self: self._parse_with_property(),
1020    }
1021
1022    CONSTRAINT_PARSERS = {
1023        "AUTOINCREMENT": lambda self: self._parse_auto_increment(),
1024        "AUTO_INCREMENT": lambda self: self._parse_auto_increment(),
1025        "CASESPECIFIC": lambda self: self.expression(exp.CaseSpecificColumnConstraint, not_=False),
1026        "CHARACTER SET": lambda self: self.expression(
1027            exp.CharacterSetColumnConstraint, this=self._parse_var_or_string()
1028        ),
1029        "CHECK": lambda self: self.expression(
1030            exp.CheckColumnConstraint,
1031            this=self._parse_wrapped(self._parse_assignment),
1032            enforced=self._match_text_seq("ENFORCED"),
1033        ),
1034        "COLLATE": lambda self: self.expression(
1035            exp.CollateColumnConstraint,
1036            this=self._parse_identifier() or self._parse_column(),
1037        ),
1038        "COMMENT": lambda self: self.expression(
1039            exp.CommentColumnConstraint, this=self._parse_string()
1040        ),
1041        "COMPRESS": lambda self: self._parse_compress(),
1042        "CLUSTERED": lambda self: self.expression(
1043            exp.ClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
1044        ),
1045        "NONCLUSTERED": lambda self: self.expression(
1046            exp.NonClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
1047        ),
1048        "DEFAULT": lambda self: self.expression(
1049            exp.DefaultColumnConstraint, this=self._parse_bitwise()
1050        ),
1051        "ENCODE": lambda self: self.expression(exp.EncodeColumnConstraint, this=self._parse_var()),
1052        "EPHEMERAL": lambda self: self.expression(
1053            exp.EphemeralColumnConstraint, this=self._parse_bitwise()
1054        ),
1055        "EXCLUDE": lambda self: self.expression(
1056            exp.ExcludeColumnConstraint, this=self._parse_index_params()
1057        ),
1058        "FOREIGN KEY": lambda self: self._parse_foreign_key(),
1059        "FORMAT": lambda self: self.expression(
1060            exp.DateFormatColumnConstraint, this=self._parse_var_or_string()
1061        ),
1062        "GENERATED": lambda self: self._parse_generated_as_identity(),
1063        "IDENTITY": lambda self: self._parse_auto_increment(),
1064        "INLINE": lambda self: self._parse_inline(),
1065        "LIKE": lambda self: self._parse_create_like(),
1066        "NOT": lambda self: self._parse_not_constraint(),
1067        "NULL": lambda self: self.expression(exp.NotNullColumnConstraint, allow_null=True),
1068        "ON": lambda self: (
1069            self._match(TokenType.UPDATE)
1070            and self.expression(exp.OnUpdateColumnConstraint, this=self._parse_function())
1071        )
1072        or self.expression(exp.OnProperty, this=self._parse_id_var()),
1073        "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()),
1074        "PERIOD": lambda self: self._parse_period_for_system_time(),
1075        "PRIMARY KEY": lambda self: self._parse_primary_key(),
1076        "REFERENCES": lambda self: self._parse_references(match=False),
1077        "TITLE": lambda self: self.expression(
1078            exp.TitleColumnConstraint, this=self._parse_var_or_string()
1079        ),
1080        "TTL": lambda self: self.expression(exp.MergeTreeTTL, expressions=[self._parse_bitwise()]),
1081        "UNIQUE": lambda self: self._parse_unique(),
1082        "UPPERCASE": lambda self: self.expression(exp.UppercaseColumnConstraint),
1083        "WATERMARK": lambda self: self.expression(
1084            exp.WatermarkColumnConstraint,
1085            this=self._match(TokenType.FOR) and self._parse_column(),
1086            expression=self._match(TokenType.ALIAS) and self._parse_disjunction(),
1087        ),
1088        "WITH": lambda self: self.expression(
1089            exp.Properties, expressions=self._parse_wrapped_properties()
1090        ),
1091    }
1092
1093    ALTER_PARSERS = {
1094        "ADD": lambda self: self._parse_alter_table_add(),
1095        "AS": lambda self: self._parse_select(),
1096        "ALTER": lambda self: self._parse_alter_table_alter(),
1097        "CLUSTER BY": lambda self: self._parse_cluster(wrapped=True),
1098        "DELETE": lambda self: self.expression(exp.Delete, where=self._parse_where()),
1099        "DROP": lambda self: self._parse_alter_table_drop(),
1100        "RENAME": lambda self: self._parse_alter_table_rename(),
1101        "SET": lambda self: self._parse_alter_table_set(),
1102        "SWAP": lambda self: self.expression(
1103            exp.SwapTable, this=self._match(TokenType.WITH) and self._parse_table(schema=True)
1104        ),
1105    }
1106
1107    ALTER_ALTER_PARSERS = {
1108        "DISTKEY": lambda self: self._parse_alter_diststyle(),
1109        "DISTSTYLE": lambda self: self._parse_alter_diststyle(),
1110        "SORTKEY": lambda self: self._parse_alter_sortkey(),
1111        "COMPOUND": lambda self: self._parse_alter_sortkey(compound=True),
1112    }
1113
1114    SCHEMA_UNNAMED_CONSTRAINTS = {
1115        "CHECK",
1116        "EXCLUDE",
1117        "FOREIGN KEY",
1118        "LIKE",
1119        "PERIOD",
1120        "PRIMARY KEY",
1121        "UNIQUE",
1122        "WATERMARK",
1123    }
1124
1125    NO_PAREN_FUNCTION_PARSERS = {
1126        "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()),
1127        "CASE": lambda self: self._parse_case(),
1128        "CONNECT_BY_ROOT": lambda self: self.expression(
1129            exp.ConnectByRoot, this=self._parse_column()
1130        ),
1131        "IF": lambda self: self._parse_if(),
1132    }
1133
1134    INVALID_FUNC_NAME_TOKENS = {
1135        TokenType.IDENTIFIER,
1136        TokenType.STRING,
1137    }
1138
1139    FUNCTIONS_WITH_ALIASED_ARGS = {"STRUCT"}
1140
1141    KEY_VALUE_DEFINITIONS = (exp.Alias, exp.EQ, exp.PropertyEQ, exp.Slice)
1142
1143    FUNCTION_PARSERS = {
1144        "CAST": lambda self: self._parse_cast(self.STRICT_CAST),
1145        "CEIL": lambda self: self._parse_ceil_floor(exp.Ceil),
1146        "CONVERT": lambda self: self._parse_convert(self.STRICT_CAST),
1147        "DECODE": lambda self: self._parse_decode(),
1148        "EXTRACT": lambda self: self._parse_extract(),
1149        "FLOOR": lambda self: self._parse_ceil_floor(exp.Floor),
1150        "GAP_FILL": lambda self: self._parse_gap_fill(),
1151        "JSON_OBJECT": lambda self: self._parse_json_object(),
1152        "JSON_OBJECTAGG": lambda self: self._parse_json_object(agg=True),
1153        "JSON_TABLE": lambda self: self._parse_json_table(),
1154        "MATCH": lambda self: self._parse_match_against(),
1155        "NORMALIZE": lambda self: self._parse_normalize(),
1156        "OPENJSON": lambda self: self._parse_open_json(),
1157        "OVERLAY": lambda self: self._parse_overlay(),
1158        "POSITION": lambda self: self._parse_position(),
1159        "PREDICT": lambda self: self._parse_predict(),
1160        "SAFE_CAST": lambda self: self._parse_cast(False, safe=True),
1161        "STRING_AGG": lambda self: self._parse_string_agg(),
1162        "SUBSTRING": lambda self: self._parse_substring(),
1163        "TRIM": lambda self: self._parse_trim(),
1164        "TRY_CAST": lambda self: self._parse_cast(False, safe=True),
1165        "TRY_CONVERT": lambda self: self._parse_convert(False, safe=True),
1166        "XMLELEMENT": lambda self: self.expression(
1167            exp.XMLElement,
1168            this=self._match_text_seq("NAME") and self._parse_id_var(),
1169            expressions=self._match(TokenType.COMMA) and self._parse_csv(self._parse_expression),
1170        ),
1171        "XMLTABLE": lambda self: self._parse_xml_table(),
1172    }
1173
1174    QUERY_MODIFIER_PARSERS = {
1175        TokenType.MATCH_RECOGNIZE: lambda self: ("match", self._parse_match_recognize()),
1176        TokenType.PREWHERE: lambda self: ("prewhere", self._parse_prewhere()),
1177        TokenType.WHERE: lambda self: ("where", self._parse_where()),
1178        TokenType.GROUP_BY: lambda self: ("group", self._parse_group()),
1179        TokenType.HAVING: lambda self: ("having", self._parse_having()),
1180        TokenType.QUALIFY: lambda self: ("qualify", self._parse_qualify()),
1181        TokenType.WINDOW: lambda self: ("windows", self._parse_window_clause()),
1182        TokenType.ORDER_BY: lambda self: ("order", self._parse_order()),
1183        TokenType.LIMIT: lambda self: ("limit", self._parse_limit()),
1184        TokenType.FETCH: lambda self: ("limit", self._parse_limit()),
1185        TokenType.OFFSET: lambda self: ("offset", self._parse_offset()),
1186        TokenType.FOR: lambda self: ("locks", self._parse_locks()),
1187        TokenType.LOCK: lambda self: ("locks", self._parse_locks()),
1188        TokenType.TABLE_SAMPLE: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
1189        TokenType.USING: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
1190        TokenType.CLUSTER_BY: lambda self: (
1191            "cluster",
1192            self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
1193        ),
1194        TokenType.DISTRIBUTE_BY: lambda self: (
1195            "distribute",
1196            self._parse_sort(exp.Distribute, TokenType.DISTRIBUTE_BY),
1197        ),
1198        TokenType.SORT_BY: lambda self: ("sort", self._parse_sort(exp.Sort, TokenType.SORT_BY)),
1199        TokenType.CONNECT_BY: lambda self: ("connect", self._parse_connect(skip_start_token=True)),
1200        TokenType.START_WITH: lambda self: ("connect", self._parse_connect()),
1201    }
1202
1203    SET_PARSERS = {
1204        "GLOBAL": lambda self: self._parse_set_item_assignment("GLOBAL"),
1205        "LOCAL": lambda self: self._parse_set_item_assignment("LOCAL"),
1206        "SESSION": lambda self: self._parse_set_item_assignment("SESSION"),
1207        "TRANSACTION": lambda self: self._parse_set_transaction(),
1208    }
1209
1210    SHOW_PARSERS: t.Dict[str, t.Callable] = {}
1211
1212    TYPE_LITERAL_PARSERS = {
1213        exp.DataType.Type.JSON: lambda self, this, _: self.expression(exp.ParseJSON, this=this),
1214    }
1215
1216    TYPE_CONVERTERS: t.Dict[exp.DataType.Type, t.Callable[[exp.DataType], exp.DataType]] = {}
1217
1218    DDL_SELECT_TOKENS = {TokenType.SELECT, TokenType.WITH, TokenType.L_PAREN}
1219
1220    PRE_VOLATILE_TOKENS = {TokenType.CREATE, TokenType.REPLACE, TokenType.UNIQUE}
1221
1222    TRANSACTION_KIND = {"DEFERRED", "IMMEDIATE", "EXCLUSIVE"}
1223    TRANSACTION_CHARACTERISTICS: OPTIONS_TYPE = {
1224        "ISOLATION": (
1225            ("LEVEL", "REPEATABLE", "READ"),
1226            ("LEVEL", "READ", "COMMITTED"),
1227            ("LEVEL", "READ", "UNCOMITTED"),
1228            ("LEVEL", "SERIALIZABLE"),
1229        ),
1230        "READ": ("WRITE", "ONLY"),
1231    }
1232
1233    CONFLICT_ACTIONS: OPTIONS_TYPE = dict.fromkeys(
1234        ("ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK", "UPDATE"), tuple()
1235    )
1236    CONFLICT_ACTIONS["DO"] = ("NOTHING", "UPDATE")
1237
1238    CREATE_SEQUENCE: OPTIONS_TYPE = {
1239        "SCALE": ("EXTEND", "NOEXTEND"),
1240        "SHARD": ("EXTEND", "NOEXTEND"),
1241        "NO": ("CYCLE", "CACHE", "MAXVALUE", "MINVALUE"),
1242        **dict.fromkeys(
1243            (
1244                "SESSION",
1245                "GLOBAL",
1246                "KEEP",
1247                "NOKEEP",
1248                "ORDER",
1249                "NOORDER",
1250                "NOCACHE",
1251                "CYCLE",
1252                "NOCYCLE",
1253                "NOMINVALUE",
1254                "NOMAXVALUE",
1255                "NOSCALE",
1256                "NOSHARD",
1257            ),
1258            tuple(),
1259        ),
1260    }
1261
1262    ISOLATED_LOADING_OPTIONS: OPTIONS_TYPE = {"FOR": ("ALL", "INSERT", "NONE")}
1263
1264    USABLES: OPTIONS_TYPE = dict.fromkeys(
1265        ("ROLE", "WAREHOUSE", "DATABASE", "SCHEMA", "CATALOG"), tuple()
1266    )
1267
1268    CAST_ACTIONS: OPTIONS_TYPE = dict.fromkeys(("RENAME", "ADD"), ("FIELDS",))
1269
1270    SCHEMA_BINDING_OPTIONS: OPTIONS_TYPE = {
1271        "TYPE": ("EVOLUTION",),
1272        **dict.fromkeys(("BINDING", "COMPENSATION", "EVOLUTION"), tuple()),
1273    }
1274
1275    PROCEDURE_OPTIONS: OPTIONS_TYPE = {}
1276
1277    EXECUTE_AS_OPTIONS: OPTIONS_TYPE = dict.fromkeys(("CALLER", "SELF", "OWNER"), tuple())
1278
1279    KEY_CONSTRAINT_OPTIONS: OPTIONS_TYPE = {
1280        "NOT": ("ENFORCED",),
1281        "MATCH": (
1282            "FULL",
1283            "PARTIAL",
1284            "SIMPLE",
1285        ),
1286        "INITIALLY": ("DEFERRED", "IMMEDIATE"),
1287        **dict.fromkeys(("DEFERRABLE", "NORELY"), tuple()),
1288    }
1289
1290    INSERT_ALTERNATIVES = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}
1291
1292    CLONE_KEYWORDS = {"CLONE", "COPY"}
1293    HISTORICAL_DATA_PREFIX = {"AT", "BEFORE", "END"}
1294    HISTORICAL_DATA_KIND = {"TIMESTAMP", "OFFSET", "STATEMENT", "STREAM"}
1295
1296    OPCLASS_FOLLOW_KEYWORDS = {"ASC", "DESC", "NULLS", "WITH"}
1297
1298    OPTYPE_FOLLOW_TOKENS = {TokenType.COMMA, TokenType.R_PAREN}
1299
1300    TABLE_INDEX_HINT_TOKENS = {TokenType.FORCE, TokenType.IGNORE, TokenType.USE}
1301
1302    VIEW_ATTRIBUTES = {"ENCRYPTION", "SCHEMABINDING", "VIEW_METADATA"}
1303
1304    WINDOW_ALIAS_TOKENS = ID_VAR_TOKENS - {TokenType.ROWS}
1305    WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER}
1306    WINDOW_SIDES = {"FOLLOWING", "PRECEDING"}
1307
1308    JSON_KEY_VALUE_SEPARATOR_TOKENS = {TokenType.COLON, TokenType.COMMA, TokenType.IS}
1309
1310    FETCH_TOKENS = ID_VAR_TOKENS - {TokenType.ROW, TokenType.ROWS, TokenType.PERCENT}
1311
1312    ADD_CONSTRAINT_TOKENS = {
1313        TokenType.CONSTRAINT,
1314        TokenType.FOREIGN_KEY,
1315        TokenType.INDEX,
1316        TokenType.KEY,
1317        TokenType.PRIMARY_KEY,
1318        TokenType.UNIQUE,
1319    }
1320
1321    DISTINCT_TOKENS = {TokenType.DISTINCT}
1322
1323    NULL_TOKENS = {TokenType.NULL}
1324
1325    UNNEST_OFFSET_ALIAS_TOKENS = ID_VAR_TOKENS - SET_OPERATIONS
1326
1327    SELECT_START_TOKENS = {TokenType.L_PAREN, TokenType.WITH, TokenType.SELECT}
1328
1329    COPY_INTO_VARLEN_OPTIONS = {"FILE_FORMAT", "COPY_OPTIONS", "FORMAT_OPTIONS", "CREDENTIAL"}
1330
1331    IS_JSON_PREDICATE_KIND = {"VALUE", "SCALAR", "ARRAY", "OBJECT"}
1332
1333    ODBC_DATETIME_LITERALS = {
1334        "d": exp.Date,
1335        "t": exp.Time,
1336        "ts": exp.Timestamp,
1337    }
1338
1339    ON_CONDITION_TOKENS = {"ERROR", "NULL", "TRUE", "FALSE", "EMPTY"}
1340
1341    PRIVILEGE_FOLLOW_TOKENS = {TokenType.ON, TokenType.COMMA, TokenType.L_PAREN}
1342
1343    # The style options for the DESCRIBE statement
1344    DESCRIBE_STYLES = {"ANALYZE", "EXTENDED", "FORMATTED", "HISTORY"}
1345
1346    # The style options for the ANALYZE statement
1347    ANALYZE_STYLES = {
1348        "BUFFER_USAGE_LIMIT",
1349        "FULL",
1350        "LOCAL",
1351        "NO_WRITE_TO_BINLOG",
1352        "SAMPLE",
1353        "SKIP_LOCKED",
1354        "VERBOSE",
1355    }
1356
1357    ANALYZE_EXPRESSION_PARSERS = {
1358        "ALL": lambda self: self._parse_analyze_columns(),
1359        "COMPUTE": lambda self: self._parse_analyze_statistics(),
1360        "DELETE": lambda self: self._parse_analyze_delete(),
1361        "DROP": lambda self: self._parse_analyze_histogram(),
1362        "ESTIMATE": lambda self: self._parse_analyze_statistics(),
1363        "LIST": lambda self: self._parse_analyze_list(),
1364        "PREDICATE": lambda self: self._parse_analyze_columns(),
1365        "UPDATE": lambda self: self._parse_analyze_histogram(),
1366        "VALIDATE": lambda self: self._parse_analyze_validate(),
1367    }
1368
1369    PARTITION_KEYWORDS = {"PARTITION", "SUBPARTITION"}
1370
1371    AMBIGUOUS_ALIAS_TOKENS = (TokenType.LIMIT, TokenType.OFFSET)
1372
1373    OPERATION_MODIFIERS: t.Set[str] = set()
1374
1375    STRICT_CAST = True
1376
1377    PREFIXED_PIVOT_COLUMNS = False
1378    IDENTIFY_PIVOT_STRINGS = False
1379
1380    LOG_DEFAULTS_TO_LN = False
1381
1382    # Whether ADD is present for each column added by ALTER TABLE
1383    ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = True
1384
1385    # Whether the table sample clause expects CSV syntax
1386    TABLESAMPLE_CSV = False
1387
1388    # The default method used for table sampling
1389    DEFAULT_SAMPLING_METHOD: t.Optional[str] = None
1390
1391    # Whether the SET command needs a delimiter (e.g. "=") for assignments
1392    SET_REQUIRES_ASSIGNMENT_DELIMITER = True
1393
1394    # Whether the TRIM function expects the characters to trim as its first argument
1395    TRIM_PATTERN_FIRST = False
1396
1397    # Whether string aliases are supported `SELECT COUNT(*) 'count'`
1398    STRING_ALIASES = False
1399
1400    # Whether query modifiers such as LIMIT are attached to the UNION node (vs its right operand)
1401    MODIFIERS_ATTACHED_TO_SET_OP = True
1402    SET_OP_MODIFIERS = {"order", "limit", "offset"}
1403
1404    # Whether to parse IF statements that aren't followed by a left parenthesis as commands
1405    NO_PAREN_IF_COMMANDS = True
1406
1407    # Whether the -> and ->> operators expect documents of type JSON (e.g. Postgres)
1408    JSON_ARROWS_REQUIRE_JSON_TYPE = False
1409
1410    # Whether the `:` operator is used to extract a value from a VARIANT column
1411    COLON_IS_VARIANT_EXTRACT = False
1412
1413    # Whether or not a VALUES keyword needs to be followed by '(' to form a VALUES clause.
1414    # If this is True and '(' is not found, the keyword will be treated as an identifier
1415    VALUES_FOLLOWED_BY_PAREN = True
1416
1417    # Whether implicit unnesting is supported, e.g. SELECT 1 FROM y.z AS z, z.a (Redshift)
1418    SUPPORTS_IMPLICIT_UNNEST = False
1419
1420    # Whether or not interval spans are supported, INTERVAL 1 YEAR TO MONTHS
1421    INTERVAL_SPANS = True
1422
1423    # Whether a PARTITION clause can follow a table reference
1424    SUPPORTS_PARTITION_SELECTION = False
1425
1426    # Whether the `name AS expr` schema/column constraint requires parentheses around `expr`
1427    WRAPPED_TRANSFORM_COLUMN_CONSTRAINT = True
1428
1429    # Whether the 'AS' keyword is optional in the CTE definition syntax
1430    OPTIONAL_ALIAS_TOKEN_CTE = True
1431
1432    __slots__ = (
1433        "error_level",
1434        "error_message_context",
1435        "max_errors",
1436        "dialect",
1437        "sql",
1438        "errors",
1439        "_tokens",
1440        "_index",
1441        "_curr",
1442        "_next",
1443        "_prev",
1444        "_prev_comments",
1445    )
1446
1447    # Autofilled
1448    SHOW_TRIE: t.Dict = {}
1449    SET_TRIE: t.Dict = {}
1450
1451    def __init__(
1452        self,
1453        error_level: t.Optional[ErrorLevel] = None,
1454        error_message_context: int = 100,
1455        max_errors: int = 3,
1456        dialect: DialectType = None,
1457    ):
1458        from sqlglot.dialects import Dialect
1459
1460        self.error_level = error_level or ErrorLevel.IMMEDIATE
1461        self.error_message_context = error_message_context
1462        self.max_errors = max_errors
1463        self.dialect = Dialect.get_or_raise(dialect)
1464        self.reset()
1465
1466    def reset(self):
1467        self.sql = ""
1468        self.errors = []
1469        self._tokens = []
1470        self._index = 0
1471        self._curr = None
1472        self._next = None
1473        self._prev = None
1474        self._prev_comments = None
1475
1476    def parse(
1477        self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
1478    ) -> t.List[t.Optional[exp.Expression]]:
1479        """
1480        Parses a list of tokens and returns a list of syntax trees, one tree
1481        per parsed SQL statement.
1482
1483        Args:
1484            raw_tokens: The list of tokens.
1485            sql: The original SQL string, used to produce helpful debug messages.
1486
1487        Returns:
1488            The list of the produced syntax trees.
1489        """
1490        return self._parse(
1491            parse_method=self.__class__._parse_statement, raw_tokens=raw_tokens, sql=sql
1492        )
1493
1494    def parse_into(
1495        self,
1496        expression_types: exp.IntoType,
1497        raw_tokens: t.List[Token],
1498        sql: t.Optional[str] = None,
1499    ) -> t.List[t.Optional[exp.Expression]]:
1500        """
1501        Parses a list of tokens into a given Expression type. If a collection of Expression
1502        types is given instead, this method will try to parse the token list into each one
1503        of them, stopping at the first for which the parsing succeeds.
1504
1505        Args:
1506            expression_types: The expression type(s) to try and parse the token list into.
1507            raw_tokens: The list of tokens.
1508            sql: The original SQL string, used to produce helpful debug messages.
1509
1510        Returns:
1511            The target Expression.
1512        """
1513        errors = []
1514        for expression_type in ensure_list(expression_types):
1515            parser = self.EXPRESSION_PARSERS.get(expression_type)
1516            if not parser:
1517                raise TypeError(f"No parser registered for {expression_type}")
1518
1519            try:
1520                return self._parse(parser, raw_tokens, sql)
1521            except ParseError as e:
1522                e.errors[0]["into_expression"] = expression_type
1523                errors.append(e)
1524
1525        raise ParseError(
1526            f"Failed to parse '{sql or raw_tokens}' into {expression_types}",
1527            errors=merge_errors(errors),
1528        ) from errors[-1]
1529
1530    def _parse(
1531        self,
1532        parse_method: t.Callable[[Parser], t.Optional[exp.Expression]],
1533        raw_tokens: t.List[Token],
1534        sql: t.Optional[str] = None,
1535    ) -> t.List[t.Optional[exp.Expression]]:
1536        self.reset()
1537        self.sql = sql or ""
1538
1539        total = len(raw_tokens)
1540        chunks: t.List[t.List[Token]] = [[]]
1541
1542        for i, token in enumerate(raw_tokens):
1543            if token.token_type == TokenType.SEMICOLON:
1544                if token.comments:
1545                    chunks.append([token])
1546
1547                if i < total - 1:
1548                    chunks.append([])
1549            else:
1550                chunks[-1].append(token)
1551
1552        expressions = []
1553
1554        for tokens in chunks:
1555            self._index = -1
1556            self._tokens = tokens
1557            self._advance()
1558
1559            expressions.append(parse_method(self))
1560
1561            if self._index < len(self._tokens):
1562                self.raise_error("Invalid expression / Unexpected token")
1563
1564            self.check_errors()
1565
1566        return expressions
1567
1568    def check_errors(self) -> None:
1569        """Logs or raises any found errors, depending on the chosen error level setting."""
1570        if self.error_level == ErrorLevel.WARN:
1571            for error in self.errors:
1572                logger.error(str(error))
1573        elif self.error_level == ErrorLevel.RAISE and self.errors:
1574            raise ParseError(
1575                concat_messages(self.errors, self.max_errors),
1576                errors=merge_errors(self.errors),
1577            )
1578
1579    def raise_error(self, message: str, token: t.Optional[Token] = None) -> None:
1580        """
1581        Appends an error in the list of recorded errors or raises it, depending on the chosen
1582        error level setting.
1583        """
1584        token = token or self._curr or self._prev or Token.string("")
1585        start = token.start
1586        end = token.end + 1
1587        start_context = self.sql[max(start - self.error_message_context, 0) : start]
1588        highlight = self.sql[start:end]
1589        end_context = self.sql[end : end + self.error_message_context]
1590
1591        error = ParseError.new(
1592            f"{message}. Line {token.line}, Col: {token.col}.\n"
1593            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
1594            description=message,
1595            line=token.line,
1596            col=token.col,
1597            start_context=start_context,
1598            highlight=highlight,
1599            end_context=end_context,
1600        )
1601
1602        if self.error_level == ErrorLevel.IMMEDIATE:
1603            raise error
1604
1605        self.errors.append(error)
1606
1607    def expression(
1608        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
1609    ) -> E:
1610        """
1611        Creates a new, validated Expression.
1612
1613        Args:
1614            exp_class: The expression class to instantiate.
1615            comments: An optional list of comments to attach to the expression.
1616            kwargs: The arguments to set for the expression along with their respective values.
1617
1618        Returns:
1619            The target expression.
1620        """
1621        instance = exp_class(**kwargs)
1622        instance.add_comments(comments) if comments else self._add_comments(instance)
1623        return self.validate_expression(instance)
1624
1625    def _add_comments(self, expression: t.Optional[exp.Expression]) -> None:
1626        if expression and self._prev_comments:
1627            expression.add_comments(self._prev_comments)
1628            self._prev_comments = None
1629
1630    def validate_expression(self, expression: E, args: t.Optional[t.List] = None) -> E:
1631        """
1632        Validates an Expression, making sure that all its mandatory arguments are set.
1633
1634        Args:
1635            expression: The expression to validate.
1636            args: An optional list of items that was used to instantiate the expression, if it's a Func.
1637
1638        Returns:
1639            The validated expression.
1640        """
1641        if self.error_level != ErrorLevel.IGNORE:
1642            for error_message in expression.error_messages(args):
1643                self.raise_error(error_message)
1644
1645        return expression
1646
1647    def _find_sql(self, start: Token, end: Token) -> str:
1648        return self.sql[start.start : end.end + 1]
1649
1650    def _is_connected(self) -> bool:
1651        return self._prev and self._curr and self._prev.end + 1 == self._curr.start
1652
1653    def _advance(self, times: int = 1) -> None:
1654        self._index += times
1655        self._curr = seq_get(self._tokens, self._index)
1656        self._next = seq_get(self._tokens, self._index + 1)
1657
1658        if self._index > 0:
1659            self._prev = self._tokens[self._index - 1]
1660            self._prev_comments = self._prev.comments
1661        else:
1662            self._prev = None
1663            self._prev_comments = None
1664
1665    def _retreat(self, index: int) -> None:
1666        if index != self._index:
1667            self._advance(index - self._index)
1668
1669    def _warn_unsupported(self) -> None:
1670        if len(self._tokens) <= 1:
1671            return
1672
1673        # We use _find_sql because self.sql may comprise multiple chunks, and we're only
1674        # interested in emitting a warning for the one being currently processed.
1675        sql = self._find_sql(self._tokens[0], self._tokens[-1])[: self.error_message_context]
1676
1677        logger.warning(
1678            f"'{sql}' contains unsupported syntax. Falling back to parsing as a 'Command'."
1679        )
1680
1681    def _parse_command(self) -> exp.Command:
1682        self._warn_unsupported()
1683        return self.expression(
1684            exp.Command,
1685            comments=self._prev_comments,
1686            this=self._prev.text.upper(),
1687            expression=self._parse_string(),
1688        )
1689
1690    def _try_parse(self, parse_method: t.Callable[[], T], retreat: bool = False) -> t.Optional[T]:
1691        """
1692        Attemps to backtrack if a parse function that contains a try/catch internally raises an error.
1693        This behavior can be different depending on the uset-set ErrorLevel, so _try_parse aims to
1694        solve this by setting & resetting the parser state accordingly
1695        """
1696        index = self._index
1697        error_level = self.error_level
1698
1699        self.error_level = ErrorLevel.IMMEDIATE
1700        try:
1701            this = parse_method()
1702        except ParseError:
1703            this = None
1704        finally:
1705            if not this or retreat:
1706                self._retreat(index)
1707            self.error_level = error_level
1708
1709        return this
1710
1711    def _parse_comment(self, allow_exists: bool = True) -> exp.Expression:
1712        start = self._prev
1713        exists = self._parse_exists() if allow_exists else None
1714
1715        self._match(TokenType.ON)
1716
1717        materialized = self._match_text_seq("MATERIALIZED")
1718        kind = self._match_set(self.CREATABLES) and self._prev
1719        if not kind:
1720            return self._parse_as_command(start)
1721
1722        if kind.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
1723            this = self._parse_user_defined_function(kind=kind.token_type)
1724        elif kind.token_type == TokenType.TABLE:
1725            this = self._parse_table(alias_tokens=self.COMMENT_TABLE_ALIAS_TOKENS)
1726        elif kind.token_type == TokenType.COLUMN:
1727            this = self._parse_column()
1728        else:
1729            this = self._parse_id_var()
1730
1731        self._match(TokenType.IS)
1732
1733        return self.expression(
1734            exp.Comment,
1735            this=this,
1736            kind=kind.text,
1737            expression=self._parse_string(),
1738            exists=exists,
1739            materialized=materialized,
1740        )
1741
1742    def _parse_to_table(
1743        self,
1744    ) -> exp.ToTableProperty:
1745        table = self._parse_table_parts(schema=True)
1746        return self.expression(exp.ToTableProperty, this=table)
1747
1748    # https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
1749    def _parse_ttl(self) -> exp.Expression:
1750        def _parse_ttl_action() -> t.Optional[exp.Expression]:
1751            this = self._parse_bitwise()
1752
1753            if self._match_text_seq("DELETE"):
1754                return self.expression(exp.MergeTreeTTLAction, this=this, delete=True)
1755            if self._match_text_seq("RECOMPRESS"):
1756                return self.expression(
1757                    exp.MergeTreeTTLAction, this=this, recompress=self._parse_bitwise()
1758                )
1759            if self._match_text_seq("TO", "DISK"):
1760                return self.expression(
1761                    exp.MergeTreeTTLAction, this=this, to_disk=self._parse_string()
1762                )
1763            if self._match_text_seq("TO", "VOLUME"):
1764                return self.expression(
1765                    exp.MergeTreeTTLAction, this=this, to_volume=self._parse_string()
1766                )
1767
1768            return this
1769
1770        expressions = self._parse_csv(_parse_ttl_action)
1771        where = self._parse_where()
1772        group = self._parse_group()
1773
1774        aggregates = None
1775        if group and self._match(TokenType.SET):
1776            aggregates = self._parse_csv(self._parse_set_item)
1777
1778        return self.expression(
1779            exp.MergeTreeTTL,
1780            expressions=expressions,
1781            where=where,
1782            group=group,
1783            aggregates=aggregates,
1784        )
1785
1786    def _parse_statement(self) -> t.Optional[exp.Expression]:
1787        if self._curr is None:
1788            return None
1789
1790        if self._match_set(self.STATEMENT_PARSERS):
1791            comments = self._prev_comments
1792            stmt = self.STATEMENT_PARSERS[self._prev.token_type](self)
1793            stmt.add_comments(comments, prepend=True)
1794            return stmt
1795
1796        if self._match_set(self.dialect.tokenizer.COMMANDS):
1797            return self._parse_command()
1798
1799        expression = self._parse_expression()
1800        expression = self._parse_set_operations(expression) if expression else self._parse_select()
1801        return self._parse_query_modifiers(expression)
1802
1803    def _parse_drop(self, exists: bool = False) -> exp.Drop | exp.Command:
1804        start = self._prev
1805        temporary = self._match(TokenType.TEMPORARY)
1806        materialized = self._match_text_seq("MATERIALIZED")
1807
1808        kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
1809        if not kind:
1810            return self._parse_as_command(start)
1811
1812        concurrently = self._match_text_seq("CONCURRENTLY")
1813        if_exists = exists or self._parse_exists()
1814
1815        if kind == "COLUMN":
1816            this = self._parse_column()
1817        else:
1818            this = self._parse_table_parts(
1819                schema=True, is_db_reference=self._prev.token_type == TokenType.SCHEMA
1820            )
1821
1822        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
1823
1824        if self._match(TokenType.L_PAREN, advance=False):
1825            expressions = self._parse_wrapped_csv(self._parse_types)
1826        else:
1827            expressions = None
1828
1829        return self.expression(
1830            exp.Drop,
1831            exists=if_exists,
1832            this=this,
1833            expressions=expressions,
1834            kind=self.dialect.CREATABLE_KIND_MAPPING.get(kind) or kind,
1835            temporary=temporary,
1836            materialized=materialized,
1837            cascade=self._match_text_seq("CASCADE"),
1838            constraints=self._match_text_seq("CONSTRAINTS"),
1839            purge=self._match_text_seq("PURGE"),
1840            cluster=cluster,
1841            concurrently=concurrently,
1842        )
1843
1844    def _parse_exists(self, not_: bool = False) -> t.Optional[bool]:
1845        return (
1846            self._match_text_seq("IF")
1847            and (not not_ or self._match(TokenType.NOT))
1848            and self._match(TokenType.EXISTS)
1849        )
1850
1851    def _parse_create(self) -> exp.Create | exp.Command:
1852        # Note: this can't be None because we've matched a statement parser
1853        start = self._prev
1854
1855        replace = (
1856            start.token_type == TokenType.REPLACE
1857            or self._match_pair(TokenType.OR, TokenType.REPLACE)
1858            or self._match_pair(TokenType.OR, TokenType.ALTER)
1859        )
1860        refresh = self._match_pair(TokenType.OR, TokenType.REFRESH)
1861
1862        unique = self._match(TokenType.UNIQUE)
1863
1864        if self._match_text_seq("CLUSTERED", "COLUMNSTORE"):
1865            clustered = True
1866        elif self._match_text_seq("NONCLUSTERED", "COLUMNSTORE") or self._match_text_seq(
1867            "COLUMNSTORE"
1868        ):
1869            clustered = False
1870        else:
1871            clustered = None
1872
1873        if self._match_pair(TokenType.TABLE, TokenType.FUNCTION, advance=False):
1874            self._advance()
1875
1876        properties = None
1877        create_token = self._match_set(self.CREATABLES) and self._prev
1878
1879        if not create_token:
1880            # exp.Properties.Location.POST_CREATE
1881            properties = self._parse_properties()
1882            create_token = self._match_set(self.CREATABLES) and self._prev
1883
1884            if not properties or not create_token:
1885                return self._parse_as_command(start)
1886
1887        concurrently = self._match_text_seq("CONCURRENTLY")
1888        exists = self._parse_exists(not_=True)
1889        this = None
1890        expression: t.Optional[exp.Expression] = None
1891        indexes = None
1892        no_schema_binding = None
1893        begin = None
1894        end = None
1895        clone = None
1896
1897        def extend_props(temp_props: t.Optional[exp.Properties]) -> None:
1898            nonlocal properties
1899            if properties and temp_props:
1900                properties.expressions.extend(temp_props.expressions)
1901            elif temp_props:
1902                properties = temp_props
1903
1904        if create_token.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
1905            this = self._parse_user_defined_function(kind=create_token.token_type)
1906
1907            # exp.Properties.Location.POST_SCHEMA ("schema" here is the UDF's type signature)
1908            extend_props(self._parse_properties())
1909
1910            expression = self._match(TokenType.ALIAS) and self._parse_heredoc()
1911            extend_props(self._parse_properties())
1912
1913            if not expression:
1914                if self._match(TokenType.COMMAND):
1915                    expression = self._parse_as_command(self._prev)
1916                else:
1917                    begin = self._match(TokenType.BEGIN)
1918                    return_ = self._match_text_seq("RETURN")
1919
1920                    if self._match(TokenType.STRING, advance=False):
1921                        # Takes care of BigQuery's JavaScript UDF definitions that end in an OPTIONS property
1922                        # # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement
1923                        expression = self._parse_string()
1924                        extend_props(self._parse_properties())
1925                    else:
1926                        expression = self._parse_user_defined_function_expression()
1927
1928                    end = self._match_text_seq("END")
1929
1930                    if return_:
1931                        expression = self.expression(exp.Return, this=expression)
1932        elif create_token.token_type == TokenType.INDEX:
1933            # Postgres allows anonymous indexes, eg. CREATE INDEX IF NOT EXISTS ON t(c)
1934            if not self._match(TokenType.ON):
1935                index = self._parse_id_var()
1936                anonymous = False
1937            else:
1938                index = None
1939                anonymous = True
1940
1941            this = self._parse_index(index=index, anonymous=anonymous)
1942        elif create_token.token_type in self.DB_CREATABLES:
1943            table_parts = self._parse_table_parts(
1944                schema=True, is_db_reference=create_token.token_type == TokenType.SCHEMA
1945            )
1946
1947            # exp.Properties.Location.POST_NAME
1948            self._match(TokenType.COMMA)
1949            extend_props(self._parse_properties(before=True))
1950
1951            this = self._parse_schema(this=table_parts)
1952
1953            # exp.Properties.Location.POST_SCHEMA and POST_WITH
1954            extend_props(self._parse_properties())
1955
1956            self._match(TokenType.ALIAS)
1957            if not self._match_set(self.DDL_SELECT_TOKENS, advance=False):
1958                # exp.Properties.Location.POST_ALIAS
1959                extend_props(self._parse_properties())
1960
1961            if create_token.token_type == TokenType.SEQUENCE:
1962                expression = self._parse_types()
1963                extend_props(self._parse_properties())
1964            else:
1965                expression = self._parse_ddl_select()
1966
1967            if create_token.token_type == TokenType.TABLE:
1968                # exp.Properties.Location.POST_EXPRESSION
1969                extend_props(self._parse_properties())
1970
1971                indexes = []
1972                while True:
1973                    index = self._parse_index()
1974
1975                    # exp.Properties.Location.POST_INDEX
1976                    extend_props(self._parse_properties())
1977                    if not index:
1978                        break
1979                    else:
1980                        self._match(TokenType.COMMA)
1981                        indexes.append(index)
1982            elif create_token.token_type == TokenType.VIEW:
1983                if self._match_text_seq("WITH", "NO", "SCHEMA", "BINDING"):
1984                    no_schema_binding = True
1985            elif create_token.token_type in (TokenType.SINK, TokenType.SOURCE):
1986                extend_props(self._parse_properties())
1987
1988            shallow = self._match_text_seq("SHALLOW")
1989
1990            if self._match_texts(self.CLONE_KEYWORDS):
1991                copy = self._prev.text.lower() == "copy"
1992                clone = self.expression(
1993                    exp.Clone, this=self._parse_table(schema=True), shallow=shallow, copy=copy
1994                )
1995
1996        if self._curr and not self._match_set((TokenType.R_PAREN, TokenType.COMMA), advance=False):
1997            return self._parse_as_command(start)
1998
1999        create_kind_text = create_token.text.upper()
2000        return self.expression(
2001            exp.Create,
2002            this=this,
2003            kind=self.dialect.CREATABLE_KIND_MAPPING.get(create_kind_text) or create_kind_text,
2004            replace=replace,
2005            refresh=refresh,
2006            unique=unique,
2007            expression=expression,
2008            exists=exists,
2009            properties=properties,
2010            indexes=indexes,
2011            no_schema_binding=no_schema_binding,
2012            begin=begin,
2013            end=end,
2014            clone=clone,
2015            concurrently=concurrently,
2016            clustered=clustered,
2017        )
2018
2019    def _parse_sequence_properties(self) -> t.Optional[exp.SequenceProperties]:
2020        seq = exp.SequenceProperties()
2021
2022        options = []
2023        index = self._index
2024
2025        while self._curr:
2026            self._match(TokenType.COMMA)
2027            if self._match_text_seq("INCREMENT"):
2028                self._match_text_seq("BY")
2029                self._match_text_seq("=")
2030                seq.set("increment", self._parse_term())
2031            elif self._match_text_seq("MINVALUE"):
2032                seq.set("minvalue", self._parse_term())
2033            elif self._match_text_seq("MAXVALUE"):
2034                seq.set("maxvalue", self._parse_term())
2035            elif self._match(TokenType.START_WITH) or self._match_text_seq("START"):
2036                self._match_text_seq("=")
2037                seq.set("start", self._parse_term())
2038            elif self._match_text_seq("CACHE"):
2039                # T-SQL allows empty CACHE which is initialized dynamically
2040                seq.set("cache", self._parse_number() or True)
2041            elif self._match_text_seq("OWNED", "BY"):
2042                # "OWNED BY NONE" is the default
2043                seq.set("owned", None if self._match_text_seq("NONE") else self._parse_column())
2044            else:
2045                opt = self._parse_var_from_options(self.CREATE_SEQUENCE, raise_unmatched=False)
2046                if opt:
2047                    options.append(opt)
2048                else:
2049                    break
2050
2051        seq.set("options", options if options else None)
2052        return None if self._index == index else seq
2053
2054    def _parse_property_before(self) -> t.Optional[exp.Expression]:
2055        # only used for teradata currently
2056        self._match(TokenType.COMMA)
2057
2058        kwargs = {
2059            "no": self._match_text_seq("NO"),
2060            "dual": self._match_text_seq("DUAL"),
2061            "before": self._match_text_seq("BEFORE"),
2062            "default": self._match_text_seq("DEFAULT"),
2063            "local": (self._match_text_seq("LOCAL") and "LOCAL")
2064            or (self._match_text_seq("NOT", "LOCAL") and "NOT LOCAL"),
2065            "after": self._match_text_seq("AFTER"),
2066            "minimum": self._match_texts(("MIN", "MINIMUM")),
2067            "maximum": self._match_texts(("MAX", "MAXIMUM")),
2068        }
2069
2070        if self._match_texts(self.PROPERTY_PARSERS):
2071            parser = self.PROPERTY_PARSERS[self._prev.text.upper()]
2072            try:
2073                return parser(self, **{k: v for k, v in kwargs.items() if v})
2074            except TypeError:
2075                self.raise_error(f"Cannot parse property '{self._prev.text}'")
2076
2077        return None
2078
2079    def _parse_wrapped_properties(self) -> t.List[exp.Expression]:
2080        return self._parse_wrapped_csv(self._parse_property)
2081
2082    def _parse_property(self) -> t.Optional[exp.Expression]:
2083        if self._match_texts(self.PROPERTY_PARSERS):
2084            return self.PROPERTY_PARSERS[self._prev.text.upper()](self)
2085
2086        if self._match(TokenType.DEFAULT) and self._match_texts(self.PROPERTY_PARSERS):
2087            return self.PROPERTY_PARSERS[self._prev.text.upper()](self, default=True)
2088
2089        if self._match_text_seq("COMPOUND", "SORTKEY"):
2090            return self._parse_sortkey(compound=True)
2091
2092        if self._match_text_seq("SQL", "SECURITY"):
2093            return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
2094
2095        index = self._index
2096        key = self._parse_column()
2097
2098        if not self._match(TokenType.EQ):
2099            self._retreat(index)
2100            return self._parse_sequence_properties()
2101
2102        # Transform the key to exp.Dot if it's dotted identifiers wrapped in exp.Column or to exp.Var otherwise
2103        if isinstance(key, exp.Column):
2104            key = key.to_dot() if len(key.parts) > 1 else exp.var(key.name)
2105
2106        value = self._parse_bitwise() or self._parse_var(any_token=True)
2107
2108        # Transform the value to exp.Var if it was parsed as exp.Column(exp.Identifier())
2109        if isinstance(value, exp.Column):
2110            value = exp.var(value.name)
2111
2112        return self.expression(exp.Property, this=key, value=value)
2113
2114    def _parse_stored(self) -> exp.FileFormatProperty:
2115        self._match(TokenType.ALIAS)
2116
2117        input_format = self._parse_string() if self._match_text_seq("INPUTFORMAT") else None
2118        output_format = self._parse_string() if self._match_text_seq("OUTPUTFORMAT") else None
2119
2120        return self.expression(
2121            exp.FileFormatProperty,
2122            this=(
2123                self.expression(
2124                    exp.InputOutputFormat, input_format=input_format, output_format=output_format
2125                )
2126                if input_format or output_format
2127                else self._parse_var_or_string() or self._parse_number() or self._parse_id_var()
2128            ),
2129        )
2130
2131    def _parse_unquoted_field(self) -> t.Optional[exp.Expression]:
2132        field = self._parse_field()
2133        if isinstance(field, exp.Identifier) and not field.quoted:
2134            field = exp.var(field)
2135
2136        return field
2137
2138    def _parse_property_assignment(self, exp_class: t.Type[E], **kwargs: t.Any) -> E:
2139        self._match(TokenType.EQ)
2140        self._match(TokenType.ALIAS)
2141
2142        return self.expression(exp_class, this=self._parse_unquoted_field(), **kwargs)
2143
2144    def _parse_properties(self, before: t.Optional[bool] = None) -> t.Optional[exp.Properties]:
2145        properties = []
2146        while True:
2147            if before:
2148                prop = self._parse_property_before()
2149            else:
2150                prop = self._parse_property()
2151            if not prop:
2152                break
2153            for p in ensure_list(prop):
2154                properties.append(p)
2155
2156        if properties:
2157            return self.expression(exp.Properties, expressions=properties)
2158
2159        return None
2160
2161    def _parse_fallback(self, no: bool = False) -> exp.FallbackProperty:
2162        return self.expression(
2163            exp.FallbackProperty, no=no, protection=self._match_text_seq("PROTECTION")
2164        )
2165
2166    def _parse_security(self) -> t.Optional[exp.SecurityProperty]:
2167        if self._match_texts(("DEFINER", "INVOKER")):
2168            security_specifier = self._prev.text.upper()
2169            return self.expression(exp.SecurityProperty, this=security_specifier)
2170        return None
2171
2172    def _parse_settings_property(self) -> exp.SettingsProperty:
2173        return self.expression(
2174            exp.SettingsProperty, expressions=self._parse_csv(self._parse_assignment)
2175        )
2176
2177    def _parse_volatile_property(self) -> exp.VolatileProperty | exp.StabilityProperty:
2178        if self._index >= 2:
2179            pre_volatile_token = self._tokens[self._index - 2]
2180        else:
2181            pre_volatile_token = None
2182
2183        if pre_volatile_token and pre_volatile_token.token_type in self.PRE_VOLATILE_TOKENS:
2184            return exp.VolatileProperty()
2185
2186        return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE"))
2187
2188    def _parse_retention_period(self) -> exp.Var:
2189        # Parse TSQL's HISTORY_RETENTION_PERIOD: {INFINITE | <number> DAY | DAYS | MONTH ...}
2190        number = self._parse_number()
2191        number_str = f"{number} " if number else ""
2192        unit = self._parse_var(any_token=True)
2193        return exp.var(f"{number_str}{unit}")
2194
2195    def _parse_system_versioning_property(
2196        self, with_: bool = False
2197    ) -> exp.WithSystemVersioningProperty:
2198        self._match(TokenType.EQ)
2199        prop = self.expression(
2200            exp.WithSystemVersioningProperty,
2201            **{  # type: ignore
2202                "on": True,
2203                "with": with_,
2204            },
2205        )
2206
2207        if self._match_text_seq("OFF"):
2208            prop.set("on", False)
2209            return prop
2210
2211        self._match(TokenType.ON)
2212        if self._match(TokenType.L_PAREN):
2213            while self._curr and not self._match(TokenType.R_PAREN):
2214                if self._match_text_seq("HISTORY_TABLE", "="):
2215                    prop.set("this", self._parse_table_parts())
2216                elif self._match_text_seq("DATA_CONSISTENCY_CHECK", "="):
2217                    prop.set("data_consistency", self._advance_any() and self._prev.text.upper())
2218                elif self._match_text_seq("HISTORY_RETENTION_PERIOD", "="):
2219                    prop.set("retention_period", self._parse_retention_period())
2220
2221                self._match(TokenType.COMMA)
2222
2223        return prop
2224
2225    def _parse_data_deletion_property(self) -> exp.DataDeletionProperty:
2226        self._match(TokenType.EQ)
2227        on = self._match_text_seq("ON") or not self._match_text_seq("OFF")
2228        prop = self.expression(exp.DataDeletionProperty, on=on)
2229
2230        if self._match(TokenType.L_PAREN):
2231            while self._curr and not self._match(TokenType.R_PAREN):
2232                if self._match_text_seq("FILTER_COLUMN", "="):
2233                    prop.set("filter_column", self._parse_column())
2234                elif self._match_text_seq("RETENTION_PERIOD", "="):
2235                    prop.set("retention_period", self._parse_retention_period())
2236
2237                self._match(TokenType.COMMA)
2238
2239        return prop
2240
2241    def _parse_distributed_property(self) -> exp.DistributedByProperty:
2242        kind = "HASH"
2243        expressions: t.Optional[t.List[exp.Expression]] = None
2244        if self._match_text_seq("BY", "HASH"):
2245            expressions = self._parse_wrapped_csv(self._parse_id_var)
2246        elif self._match_text_seq("BY", "RANDOM"):
2247            kind = "RANDOM"
2248
2249        # If the BUCKETS keyword is not present, the number of buckets is AUTO
2250        buckets: t.Optional[exp.Expression] = None
2251        if self._match_text_seq("BUCKETS") and not self._match_text_seq("AUTO"):
2252            buckets = self._parse_number()
2253
2254        return self.expression(
2255            exp.DistributedByProperty,
2256            expressions=expressions,
2257            kind=kind,
2258            buckets=buckets,
2259            order=self._parse_order(),
2260        )
2261
2262    def _parse_composite_key_property(self, expr_type: t.Type[E]) -> E:
2263        self._match_text_seq("KEY")
2264        expressions = self._parse_wrapped_id_vars()
2265        return self.expression(expr_type, expressions=expressions)
2266
2267    def _parse_with_property(self) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
2268        if self._match_text_seq("(", "SYSTEM_VERSIONING"):
2269            prop = self._parse_system_versioning_property(with_=True)
2270            self._match_r_paren()
2271            return prop
2272
2273        if self._match(TokenType.L_PAREN, advance=False):
2274            return self._parse_wrapped_properties()
2275
2276        if self._match_text_seq("JOURNAL"):
2277            return self._parse_withjournaltable()
2278
2279        if self._match_texts(self.VIEW_ATTRIBUTES):
2280            return self.expression(exp.ViewAttributeProperty, this=self._prev.text.upper())
2281
2282        if self._match_text_seq("DATA"):
2283            return self._parse_withdata(no=False)
2284        elif self._match_text_seq("NO", "DATA"):
2285            return self._parse_withdata(no=True)
2286
2287        if self._match(TokenType.SERDE_PROPERTIES, advance=False):
2288            return self._parse_serde_properties(with_=True)
2289
2290        if self._match(TokenType.SCHEMA):
2291            return self.expression(
2292                exp.WithSchemaBindingProperty,
2293                this=self._parse_var_from_options(self.SCHEMA_BINDING_OPTIONS),
2294            )
2295
2296        if self._match_texts(self.PROCEDURE_OPTIONS, advance=False):
2297            return self.expression(
2298                exp.WithProcedureOptions, expressions=self._parse_csv(self._parse_procedure_option)
2299            )
2300
2301        if not self._next:
2302            return None
2303
2304        return self._parse_withisolatedloading()
2305
2306    def _parse_procedure_option(self) -> exp.Expression | None:
2307        if self._match_text_seq("EXECUTE", "AS"):
2308            return self.expression(
2309                exp.ExecuteAsProperty,
2310                this=self._parse_var_from_options(self.EXECUTE_AS_OPTIONS, raise_unmatched=False)
2311                or self._parse_string(),
2312            )
2313
2314        return self._parse_var_from_options(self.PROCEDURE_OPTIONS)
2315
2316    # https://dev.mysql.com/doc/refman/8.0/en/create-view.html
2317    def _parse_definer(self) -> t.Optional[exp.DefinerProperty]:
2318        self._match(TokenType.EQ)
2319
2320        user = self._parse_id_var()
2321        self._match(TokenType.PARAMETER)
2322        host = self._parse_id_var() or (self._match(TokenType.MOD) and self._prev.text)
2323
2324        if not user or not host:
2325            return None
2326
2327        return exp.DefinerProperty(this=f"{user}@{host}")
2328
2329    def _parse_withjournaltable(self) -> exp.WithJournalTableProperty:
2330        self._match(TokenType.TABLE)
2331        self._match(TokenType.EQ)
2332        return self.expression(exp.WithJournalTableProperty, this=self._parse_table_parts())
2333
2334    def _parse_log(self, no: bool = False) -> exp.LogProperty:
2335        return self.expression(exp.LogProperty, no=no)
2336
2337    def _parse_journal(self, **kwargs) -> exp.JournalProperty:
2338        return self.expression(exp.JournalProperty, **kwargs)
2339
2340    def _parse_checksum(self) -> exp.ChecksumProperty:
2341        self._match(TokenType.EQ)
2342
2343        on = None
2344        if self._match(TokenType.ON):
2345            on = True
2346        elif self._match_text_seq("OFF"):
2347            on = False
2348
2349        return self.expression(exp.ChecksumProperty, on=on, default=self._match(TokenType.DEFAULT))
2350
2351    def _parse_cluster(self, wrapped: bool = False) -> exp.Cluster:
2352        return self.expression(
2353            exp.Cluster,
2354            expressions=(
2355                self._parse_wrapped_csv(self._parse_ordered)
2356                if wrapped
2357                else self._parse_csv(self._parse_ordered)
2358            ),
2359        )
2360
2361    def _parse_clustered_by(self) -> exp.ClusteredByProperty:
2362        self._match_text_seq("BY")
2363
2364        self._match_l_paren()
2365        expressions = self._parse_csv(self._parse_column)
2366        self._match_r_paren()
2367
2368        if self._match_text_seq("SORTED", "BY"):
2369            self._match_l_paren()
2370            sorted_by = self._parse_csv(self._parse_ordered)
2371            self._match_r_paren()
2372        else:
2373            sorted_by = None
2374
2375        self._match(TokenType.INTO)
2376        buckets = self._parse_number()
2377        self._match_text_seq("BUCKETS")
2378
2379        return self.expression(
2380            exp.ClusteredByProperty,
2381            expressions=expressions,
2382            sorted_by=sorted_by,
2383            buckets=buckets,
2384        )
2385
2386    def _parse_copy_property(self) -> t.Optional[exp.CopyGrantsProperty]:
2387        if not self._match_text_seq("GRANTS"):
2388            self._retreat(self._index - 1)
2389            return None
2390
2391        return self.expression(exp.CopyGrantsProperty)
2392
2393    def _parse_freespace(self) -> exp.FreespaceProperty:
2394        self._match(TokenType.EQ)
2395        return self.expression(
2396            exp.FreespaceProperty, this=self._parse_number(), percent=self._match(TokenType.PERCENT)
2397        )
2398
2399    def _parse_mergeblockratio(
2400        self, no: bool = False, default: bool = False
2401    ) -> exp.MergeBlockRatioProperty:
2402        if self._match(TokenType.EQ):
2403            return self.expression(
2404                exp.MergeBlockRatioProperty,
2405                this=self._parse_number(),
2406                percent=self._match(TokenType.PERCENT),
2407            )
2408
2409        return self.expression(exp.MergeBlockRatioProperty, no=no, default=default)
2410
2411    def _parse_datablocksize(
2412        self,
2413        default: t.Optional[bool] = None,
2414        minimum: t.Optional[bool] = None,
2415        maximum: t.Optional[bool] = None,
2416    ) -> exp.DataBlocksizeProperty:
2417        self._match(TokenType.EQ)
2418        size = self._parse_number()
2419
2420        units = None
2421        if self._match_texts(("BYTES", "KBYTES", "KILOBYTES")):
2422            units = self._prev.text
2423
2424        return self.expression(
2425            exp.DataBlocksizeProperty,
2426            size=size,
2427            units=units,
2428            default=default,
2429            minimum=minimum,
2430            maximum=maximum,
2431        )
2432
2433    def _parse_blockcompression(self) -> exp.BlockCompressionProperty:
2434        self._match(TokenType.EQ)
2435        always = self._match_text_seq("ALWAYS")
2436        manual = self._match_text_seq("MANUAL")
2437        never = self._match_text_seq("NEVER")
2438        default = self._match_text_seq("DEFAULT")
2439
2440        autotemp = None
2441        if self._match_text_seq("AUTOTEMP"):
2442            autotemp = self._parse_schema()
2443
2444        return self.expression(
2445            exp.BlockCompressionProperty,
2446            always=always,
2447            manual=manual,
2448            never=never,
2449            default=default,
2450            autotemp=autotemp,
2451        )
2452
2453    def _parse_withisolatedloading(self) -> t.Optional[exp.IsolatedLoadingProperty]:
2454        index = self._index
2455        no = self._match_text_seq("NO")
2456        concurrent = self._match_text_seq("CONCURRENT")
2457
2458        if not self._match_text_seq("ISOLATED", "LOADING"):
2459            self._retreat(index)
2460            return None
2461
2462        target = self._parse_var_from_options(self.ISOLATED_LOADING_OPTIONS, raise_unmatched=False)
2463        return self.expression(
2464            exp.IsolatedLoadingProperty, no=no, concurrent=concurrent, target=target
2465        )
2466
2467    def _parse_locking(self) -> exp.LockingProperty:
2468        if self._match(TokenType.TABLE):
2469            kind = "TABLE"
2470        elif self._match(TokenType.VIEW):
2471            kind = "VIEW"
2472        elif self._match(TokenType.ROW):
2473            kind = "ROW"
2474        elif self._match_text_seq("DATABASE"):
2475            kind = "DATABASE"
2476        else:
2477            kind = None
2478
2479        if kind in ("DATABASE", "TABLE", "VIEW"):
2480            this = self._parse_table_parts()
2481        else:
2482            this = None
2483
2484        if self._match(TokenType.FOR):
2485            for_or_in = "FOR"
2486        elif self._match(TokenType.IN):
2487            for_or_in = "IN"
2488        else:
2489            for_or_in = None
2490
2491        if self._match_text_seq("ACCESS"):
2492            lock_type = "ACCESS"
2493        elif self._match_texts(("EXCL", "EXCLUSIVE")):
2494            lock_type = "EXCLUSIVE"
2495        elif self._match_text_seq("SHARE"):
2496            lock_type = "SHARE"
2497        elif self._match_text_seq("READ"):
2498            lock_type = "READ"
2499        elif self._match_text_seq("WRITE"):
2500            lock_type = "WRITE"
2501        elif self._match_text_seq("CHECKSUM"):
2502            lock_type = "CHECKSUM"
2503        else:
2504            lock_type = None
2505
2506        override = self._match_text_seq("OVERRIDE")
2507
2508        return self.expression(
2509            exp.LockingProperty,
2510            this=this,
2511            kind=kind,
2512            for_or_in=for_or_in,
2513            lock_type=lock_type,
2514            override=override,
2515        )
2516
2517    def _parse_partition_by(self) -> t.List[exp.Expression]:
2518        if self._match(TokenType.PARTITION_BY):
2519            return self._parse_csv(self._parse_assignment)
2520        return []
2521
2522    def _parse_partition_bound_spec(self) -> exp.PartitionBoundSpec:
2523        def _parse_partition_bound_expr() -> t.Optional[exp.Expression]:
2524            if self._match_text_seq("MINVALUE"):
2525                return exp.var("MINVALUE")
2526            if self._match_text_seq("MAXVALUE"):
2527                return exp.var("MAXVALUE")
2528            return self._parse_bitwise()
2529
2530        this: t.Optional[exp.Expression | t.List[exp.Expression]] = None
2531        expression = None
2532        from_expressions = None
2533        to_expressions = None
2534
2535        if self._match(TokenType.IN):
2536            this = self._parse_wrapped_csv(self._parse_bitwise)
2537        elif self._match(TokenType.FROM):
2538            from_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
2539            self._match_text_seq("TO")
2540            to_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
2541        elif self._match_text_seq("WITH", "(", "MODULUS"):
2542            this = self._parse_number()
2543            self._match_text_seq(",", "REMAINDER")
2544            expression = self._parse_number()
2545            self._match_r_paren()
2546        else:
2547            self.raise_error("Failed to parse partition bound spec.")
2548
2549        return self.expression(
2550            exp.PartitionBoundSpec,
2551            this=this,
2552            expression=expression,
2553            from_expressions=from_expressions,
2554            to_expressions=to_expressions,
2555        )
2556
2557    # https://www.postgresql.org/docs/current/sql-createtable.html
2558    def _parse_partitioned_of(self) -> t.Optional[exp.PartitionedOfProperty]:
2559        if not self._match_text_seq("OF"):
2560            self._retreat(self._index - 1)
2561            return None
2562
2563        this = self._parse_table(schema=True)
2564
2565        if self._match(TokenType.DEFAULT):
2566            expression: exp.Var | exp.PartitionBoundSpec = exp.var("DEFAULT")
2567        elif self._match_text_seq("FOR", "VALUES"):
2568            expression = self._parse_partition_bound_spec()
2569        else:
2570            self.raise_error("Expecting either DEFAULT or FOR VALUES clause.")
2571
2572        return self.expression(exp.PartitionedOfProperty, this=this, expression=expression)
2573
2574    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
2575        self._match(TokenType.EQ)
2576        return self.expression(
2577            exp.PartitionedByProperty,
2578            this=self._parse_schema() or self._parse_bracket(self._parse_field()),
2579        )
2580
2581    def _parse_withdata(self, no: bool = False) -> exp.WithDataProperty:
2582        if self._match_text_seq("AND", "STATISTICS"):
2583            statistics = True
2584        elif self._match_text_seq("AND", "NO", "STATISTICS"):
2585            statistics = False
2586        else:
2587            statistics = None
2588
2589        return self.expression(exp.WithDataProperty, no=no, statistics=statistics)
2590
2591    def _parse_contains_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2592        if self._match_text_seq("SQL"):
2593            return self.expression(exp.SqlReadWriteProperty, this="CONTAINS SQL")
2594        return None
2595
2596    def _parse_modifies_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2597        if self._match_text_seq("SQL", "DATA"):
2598            return self.expression(exp.SqlReadWriteProperty, this="MODIFIES SQL DATA")
2599        return None
2600
2601    def _parse_no_property(self) -> t.Optional[exp.Expression]:
2602        if self._match_text_seq("PRIMARY", "INDEX"):
2603            return exp.NoPrimaryIndexProperty()
2604        if self._match_text_seq("SQL"):
2605            return self.expression(exp.SqlReadWriteProperty, this="NO SQL")
2606        return None
2607
2608    def _parse_on_property(self) -> t.Optional[exp.Expression]:
2609        if self._match_text_seq("COMMIT", "PRESERVE", "ROWS"):
2610            return exp.OnCommitProperty()
2611        if self._match_text_seq("COMMIT", "DELETE", "ROWS"):
2612            return exp.OnCommitProperty(delete=True)
2613        return self.expression(exp.OnProperty, this=self._parse_schema(self._parse_id_var()))
2614
2615    def _parse_reads_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2616        if self._match_text_seq("SQL", "DATA"):
2617            return self.expression(exp.SqlReadWriteProperty, this="READS SQL DATA")
2618        return None
2619
2620    def _parse_distkey(self) -> exp.DistKeyProperty:
2621        return self.expression(exp.DistKeyProperty, this=self._parse_wrapped(self._parse_id_var))
2622
2623    def _parse_create_like(self) -> t.Optional[exp.LikeProperty]:
2624        table = self._parse_table(schema=True)
2625
2626        options = []
2627        while self._match_texts(("INCLUDING", "EXCLUDING")):
2628            this = self._prev.text.upper()
2629
2630            id_var = self._parse_id_var()
2631            if not id_var:
2632                return None
2633
2634            options.append(
2635                self.expression(exp.Property, this=this, value=exp.var(id_var.this.upper()))
2636            )
2637
2638        return self.expression(exp.LikeProperty, this=table, expressions=options)
2639
2640    def _parse_sortkey(self, compound: bool = False) -> exp.SortKeyProperty:
2641        return self.expression(
2642            exp.SortKeyProperty, this=self._parse_wrapped_id_vars(), compound=compound
2643        )
2644
2645    def _parse_character_set(self, default: bool = False) -> exp.CharacterSetProperty:
2646        self._match(TokenType.EQ)
2647        return self.expression(
2648            exp.CharacterSetProperty, this=self._parse_var_or_string(), default=default
2649        )
2650
2651    def _parse_remote_with_connection(self) -> exp.RemoteWithConnectionModelProperty:
2652        self._match_text_seq("WITH", "CONNECTION")
2653        return self.expression(
2654            exp.RemoteWithConnectionModelProperty, this=self._parse_table_parts()
2655        )
2656
2657    def _parse_returns(self) -> exp.ReturnsProperty:
2658        value: t.Optional[exp.Expression]
2659        null = None
2660        is_table = self._match(TokenType.TABLE)
2661
2662        if is_table:
2663            if self._match(TokenType.LT):
2664                value = self.expression(
2665                    exp.Schema,
2666                    this="TABLE",
2667                    expressions=self._parse_csv(self._parse_struct_types),
2668                )
2669                if not self._match(TokenType.GT):
2670                    self.raise_error("Expecting >")
2671            else:
2672                value = self._parse_schema(exp.var("TABLE"))
2673        elif self._match_text_seq("NULL", "ON", "NULL", "INPUT"):
2674            null = True
2675            value = None
2676        else:
2677            value = self._parse_types()
2678
2679        return self.expression(exp.ReturnsProperty, this=value, is_table=is_table, null=null)
2680
2681    def _parse_describe(self) -> exp.Describe:
2682        kind = self._match_set(self.CREATABLES) and self._prev.text
2683        style = self._match_texts(self.DESCRIBE_STYLES) and self._prev.text.upper()
2684        if self._match(TokenType.DOT):
2685            style = None
2686            self._retreat(self._index - 2)
2687
2688        format = self._parse_property() if self._match(TokenType.FORMAT, advance=False) else None
2689
2690        if self._match_set(self.STATEMENT_PARSERS, advance=False):
2691            this = self._parse_statement()
2692        else:
2693            this = self._parse_table(schema=True)
2694
2695        properties = self._parse_properties()
2696        expressions = properties.expressions if properties else None
2697        partition = self._parse_partition()
2698        return self.expression(
2699            exp.Describe,
2700            this=this,
2701            style=style,
2702            kind=kind,
2703            expressions=expressions,
2704            partition=partition,
2705            format=format,
2706        )
2707
2708    def _parse_multitable_inserts(self, comments: t.Optional[t.List[str]]) -> exp.MultitableInserts:
2709        kind = self._prev.text.upper()
2710        expressions = []
2711
2712        def parse_conditional_insert() -> t.Optional[exp.ConditionalInsert]:
2713            if self._match(TokenType.WHEN):
2714                expression = self._parse_disjunction()
2715                self._match(TokenType.THEN)
2716            else:
2717                expression = None
2718
2719            else_ = self._match(TokenType.ELSE)
2720
2721            if not self._match(TokenType.INTO):
2722                return None
2723
2724            return self.expression(
2725                exp.ConditionalInsert,
2726                this=self.expression(
2727                    exp.Insert,
2728                    this=self._parse_table(schema=True),
2729                    expression=self._parse_derived_table_values(),
2730                ),
2731                expression=expression,
2732                else_=else_,
2733            )
2734
2735        expression = parse_conditional_insert()
2736        while expression is not None:
2737            expressions.append(expression)
2738            expression = parse_conditional_insert()
2739
2740        return self.expression(
2741            exp.MultitableInserts,
2742            kind=kind,
2743            comments=comments,
2744            expressions=expressions,
2745            source=self._parse_table(),
2746        )
2747
2748    def _parse_insert(self) -> t.Union[exp.Insert, exp.MultitableInserts]:
2749        comments = []
2750        hint = self._parse_hint()
2751        overwrite = self._match(TokenType.OVERWRITE)
2752        ignore = self._match(TokenType.IGNORE)
2753        local = self._match_text_seq("LOCAL")
2754        alternative = None
2755        is_function = None
2756
2757        if self._match_text_seq("DIRECTORY"):
2758            this: t.Optional[exp.Expression] = self.expression(
2759                exp.Directory,
2760                this=self._parse_var_or_string(),
2761                local=local,
2762                row_format=self._parse_row_format(match_row=True),
2763            )
2764        else:
2765            if self._match_set((TokenType.FIRST, TokenType.ALL)):
2766                comments += ensure_list(self._prev_comments)
2767                return self._parse_multitable_inserts(comments)
2768
2769            if self._match(TokenType.OR):
2770                alternative = self._match_texts(self.INSERT_ALTERNATIVES) and self._prev.text
2771
2772            self._match(TokenType.INTO)
2773            comments += ensure_list(self._prev_comments)
2774            self._match(TokenType.TABLE)
2775            is_function = self._match(TokenType.FUNCTION)
2776
2777            this = (
2778                self._parse_table(schema=True, parse_partition=True)
2779                if not is_function
2780                else self._parse_function()
2781            )
2782            if isinstance(this, exp.Table) and self._match(TokenType.ALIAS, advance=False):
2783                this.set("alias", self._parse_table_alias())
2784
2785        returning = self._parse_returning()
2786
2787        return self.expression(
2788            exp.Insert,
2789            comments=comments,
2790            hint=hint,
2791            is_function=is_function,
2792            this=this,
2793            stored=self._match_text_seq("STORED") and self._parse_stored(),
2794            by_name=self._match_text_seq("BY", "NAME"),
2795            exists=self._parse_exists(),
2796            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE) and self._parse_assignment(),
2797            partition=self._match(TokenType.PARTITION_BY) and self._parse_partitioned_by(),
2798            settings=self._match_text_seq("SETTINGS") and self._parse_settings_property(),
2799            expression=self._parse_derived_table_values() or self._parse_ddl_select(),
2800            conflict=self._parse_on_conflict(),
2801            returning=returning or self._parse_returning(),
2802            overwrite=overwrite,
2803            alternative=alternative,
2804            ignore=ignore,
2805            source=self._match(TokenType.TABLE) and self._parse_table(),
2806        )
2807
2808    def _parse_kill(self) -> exp.Kill:
2809        kind = exp.var(self._prev.text) if self._match_texts(("CONNECTION", "QUERY")) else None
2810
2811        return self.expression(
2812            exp.Kill,
2813            this=self._parse_primary(),
2814            kind=kind,
2815        )
2816
2817    def _parse_on_conflict(self) -> t.Optional[exp.OnConflict]:
2818        conflict = self._match_text_seq("ON", "CONFLICT")
2819        duplicate = self._match_text_seq("ON", "DUPLICATE", "KEY")
2820
2821        if not conflict and not duplicate:
2822            return None
2823
2824        conflict_keys = None
2825        constraint = None
2826
2827        if conflict:
2828            if self._match_text_seq("ON", "CONSTRAINT"):
2829                constraint = self._parse_id_var()
2830            elif self._match(TokenType.L_PAREN):
2831                conflict_keys = self._parse_csv(self._parse_id_var)
2832                self._match_r_paren()
2833
2834        action = self._parse_var_from_options(self.CONFLICT_ACTIONS)
2835        if self._prev.token_type == TokenType.UPDATE:
2836            self._match(TokenType.SET)
2837            expressions = self._parse_csv(self._parse_equality)
2838        else:
2839            expressions = None
2840
2841        return self.expression(
2842            exp.OnConflict,
2843            duplicate=duplicate,
2844            expressions=expressions,
2845            action=action,
2846            conflict_keys=conflict_keys,
2847            constraint=constraint,
2848            where=self._parse_where(),
2849        )
2850
2851    def _parse_returning(self) -> t.Optional[exp.Returning]:
2852        if not self._match(TokenType.RETURNING):
2853            return None
2854        return self.expression(
2855            exp.Returning,
2856            expressions=self._parse_csv(self._parse_expression),
2857            into=self._match(TokenType.INTO) and self._parse_table_part(),
2858        )
2859
2860    def _parse_row(self) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
2861        if not self._match(TokenType.FORMAT):
2862            return None
2863        return self._parse_row_format()
2864
2865    def _parse_serde_properties(self, with_: bool = False) -> t.Optional[exp.SerdeProperties]:
2866        index = self._index
2867        with_ = with_ or self._match_text_seq("WITH")
2868
2869        if not self._match(TokenType.SERDE_PROPERTIES):
2870            self._retreat(index)
2871            return None
2872        return self.expression(
2873            exp.SerdeProperties,
2874            **{  # type: ignore
2875                "expressions": self._parse_wrapped_properties(),
2876                "with": with_,
2877            },
2878        )
2879
2880    def _parse_row_format(
2881        self, match_row: bool = False
2882    ) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
2883        if match_row and not self._match_pair(TokenType.ROW, TokenType.FORMAT):
2884            return None
2885
2886        if self._match_text_seq("SERDE"):
2887            this = self._parse_string()
2888
2889            serde_properties = self._parse_serde_properties()
2890
2891            return self.expression(
2892                exp.RowFormatSerdeProperty, this=this, serde_properties=serde_properties
2893            )
2894
2895        self._match_text_seq("DELIMITED")
2896
2897        kwargs = {}
2898
2899        if self._match_text_seq("FIELDS", "TERMINATED", "BY"):
2900            kwargs["fields"] = self._parse_string()
2901            if self._match_text_seq("ESCAPED", "BY"):
2902                kwargs["escaped"] = self._parse_string()
2903        if self._match_text_seq("COLLECTION", "ITEMS", "TERMINATED", "BY"):
2904            kwargs["collection_items"] = self._parse_string()
2905        if self._match_text_seq("MAP", "KEYS", "TERMINATED", "BY"):
2906            kwargs["map_keys"] = self._parse_string()
2907        if self._match_text_seq("LINES", "TERMINATED", "BY"):
2908            kwargs["lines"] = self._parse_string()
2909        if self._match_text_seq("NULL", "DEFINED", "AS"):
2910            kwargs["null"] = self._parse_string()
2911
2912        return self.expression(exp.RowFormatDelimitedProperty, **kwargs)  # type: ignore
2913
2914    def _parse_load(self) -> exp.LoadData | exp.Command:
2915        if self._match_text_seq("DATA"):
2916            local = self._match_text_seq("LOCAL")
2917            self._match_text_seq("INPATH")
2918            inpath = self._parse_string()
2919            overwrite = self._match(TokenType.OVERWRITE)
2920            self._match_pair(TokenType.INTO, TokenType.TABLE)
2921
2922            return self.expression(
2923                exp.LoadData,
2924                this=self._parse_table(schema=True),
2925                local=local,
2926                overwrite=overwrite,
2927                inpath=inpath,
2928                partition=self._parse_partition(),
2929                input_format=self._match_text_seq("INPUTFORMAT") and self._parse_string(),
2930                serde=self._match_text_seq("SERDE") and self._parse_string(),
2931            )
2932        return self._parse_as_command(self._prev)
2933
2934    def _parse_delete(self) -> exp.Delete:
2935        # This handles MySQL's "Multiple-Table Syntax"
2936        # https://dev.mysql.com/doc/refman/8.0/en/delete.html
2937        tables = None
2938        if not self._match(TokenType.FROM, advance=False):
2939            tables = self._parse_csv(self._parse_table) or None
2940
2941        returning = self._parse_returning()
2942
2943        return self.expression(
2944            exp.Delete,
2945            tables=tables,
2946            this=self._match(TokenType.FROM) and self._parse_table(joins=True),
2947            using=self._match(TokenType.USING) and self._parse_table(joins=True),
2948            cluster=self._match(TokenType.ON) and self._parse_on_property(),
2949            where=self._parse_where(),
2950            returning=returning or self._parse_returning(),
2951            limit=self._parse_limit(),
2952        )
2953
2954    def _parse_update(self) -> exp.Update:
2955        this = self._parse_table(joins=True, alias_tokens=self.UPDATE_ALIAS_TOKENS)
2956        expressions = self._match(TokenType.SET) and self._parse_csv(self._parse_equality)
2957        returning = self._parse_returning()
2958        return self.expression(
2959            exp.Update,
2960            **{  # type: ignore
2961                "this": this,
2962                "expressions": expressions,
2963                "from": self._parse_from(joins=True),
2964                "where": self._parse_where(),
2965                "returning": returning or self._parse_returning(),
2966                "order": self._parse_order(),
2967                "limit": self._parse_limit(),
2968            },
2969        )
2970
2971    def _parse_uncache(self) -> exp.Uncache:
2972        if not self._match(TokenType.TABLE):
2973            self.raise_error("Expecting TABLE after UNCACHE")
2974
2975        return self.expression(
2976            exp.Uncache, exists=self._parse_exists(), this=self._parse_table(schema=True)
2977        )
2978
2979    def _parse_cache(self) -> exp.Cache:
2980        lazy = self._match_text_seq("LAZY")
2981        self._match(TokenType.TABLE)
2982        table = self._parse_table(schema=True)
2983
2984        options = []
2985        if self._match_text_seq("OPTIONS"):
2986            self._match_l_paren()
2987            k = self._parse_string()
2988            self._match(TokenType.EQ)
2989            v = self._parse_string()
2990            options = [k, v]
2991            self._match_r_paren()
2992
2993        self._match(TokenType.ALIAS)
2994        return self.expression(
2995            exp.Cache,
2996            this=table,
2997            lazy=lazy,
2998            options=options,
2999            expression=self._parse_select(nested=True),
3000        )
3001
3002    def _parse_partition(self) -> t.Optional[exp.Partition]:
3003        if not self._match_texts(self.PARTITION_KEYWORDS):
3004            return None
3005
3006        return self.expression(
3007            exp.Partition,
3008            subpartition=self._prev.text.upper() == "SUBPARTITION",
3009            expressions=self._parse_wrapped_csv(self._parse_assignment),
3010        )
3011
3012    def _parse_value(self) -> t.Optional[exp.Tuple]:
3013        def _parse_value_expression() -> t.Optional[exp.Expression]:
3014            if self.dialect.SUPPORTS_VALUES_DEFAULT and self._match(TokenType.DEFAULT):
3015                return exp.var(self._prev.text.upper())
3016            return self._parse_expression()
3017
3018        if self._match(TokenType.L_PAREN):
3019            expressions = self._parse_csv(_parse_value_expression)
3020            self._match_r_paren()
3021            return self.expression(exp.Tuple, expressions=expressions)
3022
3023        # In some dialects we can have VALUES 1, 2 which results in 1 column & 2 rows.
3024        expression = self._parse_expression()
3025        if expression:
3026            return self.expression(exp.Tuple, expressions=[expression])
3027        return None
3028
3029    def _parse_projections(self) -> t.List[exp.Expression]:
3030        return self._parse_expressions()
3031
3032    def _parse_select(
3033        self,
3034        nested: bool = False,
3035        table: bool = False,
3036        parse_subquery_alias: bool = True,
3037        parse_set_operation: bool = True,
3038    ) -> t.Optional[exp.Expression]:
3039        cte = self._parse_with()
3040
3041        if cte:
3042            this = self._parse_statement()
3043
3044            if not this:
3045                self.raise_error("Failed to parse any statement following CTE")
3046                return cte
3047
3048            if "with" in this.arg_types:
3049                this.set("with", cte)
3050            else:
3051                self.raise_error(f"{this.key} does not support CTE")
3052                this = cte
3053
3054            return this
3055
3056        # duckdb supports leading with FROM x
3057        from_ = self._parse_from() if self._match(TokenType.FROM, advance=False) else None
3058
3059        if self._match(TokenType.SELECT):
3060            comments = self._prev_comments
3061
3062            hint = self._parse_hint()
3063
3064            if self._next and not self._next.token_type == TokenType.DOT:
3065                all_ = self._match(TokenType.ALL)
3066                distinct = self._match_set(self.DISTINCT_TOKENS)
3067            else:
3068                all_, distinct = None, None
3069
3070            kind = (
3071                self._match(TokenType.ALIAS)
3072                and self._match_texts(("STRUCT", "VALUE"))
3073                and self._prev.text.upper()
3074            )
3075
3076            if distinct:
3077                distinct = self.expression(
3078                    exp.Distinct,
3079                    on=self._parse_value() if self._match(TokenType.ON) else None,
3080                )
3081
3082            if all_ and distinct:
3083                self.raise_error("Cannot specify both ALL and DISTINCT after SELECT")
3084
3085            operation_modifiers = []
3086            while self._curr and self._match_texts(self.OPERATION_MODIFIERS):
3087                operation_modifiers.append(exp.var(self._prev.text.upper()))
3088
3089            limit = self._parse_limit(top=True)
3090            projections = self._parse_projections()
3091
3092            this = self.expression(
3093                exp.Select,
3094                kind=kind,
3095                hint=hint,
3096                distinct=distinct,
3097                expressions=projections,
3098                limit=limit,
3099                operation_modifiers=operation_modifiers or None,
3100            )
3101            this.comments = comments
3102
3103            into = self._parse_into()
3104            if into:
3105                this.set("into", into)
3106
3107            if not from_:
3108                from_ = self._parse_from()
3109
3110            if from_:
3111                this.set("from", from_)
3112
3113            this = self._parse_query_modifiers(this)
3114        elif (table or nested) and self._match(TokenType.L_PAREN):
3115            if self._match_set((TokenType.PIVOT, TokenType.UNPIVOT)):
3116                this = self._parse_simplified_pivot(
3117                    is_unpivot=self._prev.token_type == TokenType.UNPIVOT
3118                )
3119            elif self._match(TokenType.FROM):
3120                from_ = self._parse_from(skip_from_token=True)
3121                # Support parentheses for duckdb FROM-first syntax
3122                select = self._parse_select()
3123                if select:
3124                    select.set("from", from_)
3125                    this = select
3126                else:
3127                    this = exp.select("*").from_(t.cast(exp.From, from_))
3128            else:
3129                this = (
3130                    self._parse_table()
3131                    if table
3132                    else self._parse_select(nested=True, parse_set_operation=False)
3133                )
3134
3135                # Transform exp.Values into a exp.Table to pass through parse_query_modifiers
3136                # in case a modifier (e.g. join) is following
3137                if table and isinstance(this, exp.Values) and this.alias:
3138                    alias = this.args["alias"].pop()
3139                    this = exp.Table(this=this, alias=alias)
3140
3141                this = self._parse_query_modifiers(self._parse_set_operations(this))
3142
3143            self._match_r_paren()
3144
3145            # We return early here so that the UNION isn't attached to the subquery by the
3146            # following call to _parse_set_operations, but instead becomes the parent node
3147            return self._parse_subquery(this, parse_alias=parse_subquery_alias)
3148        elif self._match(TokenType.VALUES, advance=False):
3149            this = self._parse_derived_table_values()
3150        elif from_:
3151            this = exp.select("*").from_(from_.this, copy=False)
3152        elif self._match(TokenType.SUMMARIZE):
3153            table = self._match(TokenType.TABLE)
3154            this = self._parse_select() or self._parse_string() or self._parse_table()
3155            return self.expression(exp.Summarize, this=this, table=table)
3156        elif self._match(TokenType.DESCRIBE):
3157            this = self._parse_describe()
3158        elif self._match_text_seq("STREAM"):
3159            this = self._parse_function()
3160            if this:
3161                this = self.expression(exp.Stream, this=this)
3162            else:
3163                self._retreat(self._index - 1)
3164        else:
3165            this = None
3166
3167        return self._parse_set_operations(this) if parse_set_operation else this
3168
3169    def _parse_with(self, skip_with_token: bool = False) -> t.Optional[exp.With]:
3170        if not skip_with_token and not self._match(TokenType.WITH):
3171            return None
3172
3173        comments = self._prev_comments
3174        recursive = self._match(TokenType.RECURSIVE)
3175
3176        last_comments = None
3177        expressions = []
3178        while True:
3179            expressions.append(self._parse_cte())
3180            if last_comments:
3181                expressions[-1].add_comments(last_comments)
3182
3183            if not self._match(TokenType.COMMA) and not self._match(TokenType.WITH):
3184                break
3185            else:
3186                self._match(TokenType.WITH)
3187
3188            last_comments = self._prev_comments
3189
3190        return self.expression(
3191            exp.With, comments=comments, expressions=expressions, recursive=recursive
3192        )
3193
3194    def _parse_cte(self) -> t.Optional[exp.CTE]:
3195        index = self._index
3196
3197        alias = self._parse_table_alias(self.ID_VAR_TOKENS)
3198        if not alias or not alias.this:
3199            self.raise_error("Expected CTE to have alias")
3200
3201        if not self._match(TokenType.ALIAS) and not self.OPTIONAL_ALIAS_TOKEN_CTE:
3202            self._retreat(index)
3203            return None
3204
3205        comments = self._prev_comments
3206
3207        if self._match_text_seq("NOT", "MATERIALIZED"):
3208            materialized = False
3209        elif self._match_text_seq("MATERIALIZED"):
3210            materialized = True
3211        else:
3212            materialized = None
3213
3214        cte = self.expression(
3215            exp.CTE,
3216            this=self._parse_wrapped(self._parse_statement),
3217            alias=alias,
3218            materialized=materialized,
3219            comments=comments,
3220        )
3221
3222        if isinstance(cte.this, exp.Values):
3223            cte.set("this", exp.select("*").from_(exp.alias_(cte.this, "_values", table=True)))
3224
3225        return cte
3226
3227    def _parse_table_alias(
3228        self, alias_tokens: t.Optional[t.Collection[TokenType]] = None
3229    ) -> t.Optional[exp.TableAlias]:
3230        # In some dialects, LIMIT and OFFSET can act as both identifiers and keywords (clauses)
3231        # so this section tries to parse the clause version and if it fails, it treats the token
3232        # as an identifier (alias)
3233        if self._can_parse_limit_or_offset():
3234            return None
3235
3236        any_token = self._match(TokenType.ALIAS)
3237        alias = (
3238            self._parse_id_var(any_token=any_token, tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
3239            or self._parse_string_as_identifier()
3240        )
3241
3242        index = self._index
3243        if self._match(TokenType.L_PAREN):
3244            columns = self._parse_csv(self._parse_function_parameter)
3245            self._match_r_paren() if columns else self._retreat(index)
3246        else:
3247            columns = None
3248
3249        if not alias and not columns:
3250            return None
3251
3252        table_alias = self.expression(exp.TableAlias, this=alias, columns=columns)
3253
3254        # We bubble up comments from the Identifier to the TableAlias
3255        if isinstance(alias, exp.Identifier):
3256            table_alias.add_comments(alias.pop_comments())
3257
3258        return table_alias
3259
3260    def _parse_subquery(
3261        self, this: t.Optional[exp.Expression], parse_alias: bool = True
3262    ) -> t.Optional[exp.Subquery]:
3263        if not this:
3264            return None
3265
3266        return self.expression(
3267            exp.Subquery,
3268            this=this,
3269            pivots=self._parse_pivots(),
3270            alias=self._parse_table_alias() if parse_alias else None,
3271            sample=self._parse_table_sample(),
3272        )
3273
3274    def _implicit_unnests_to_explicit(self, this: E) -> E:
3275        from sqlglot.optimizer.normalize_identifiers import normalize_identifiers as _norm
3276
3277        refs = {_norm(this.args["from"].this.copy(), dialect=self.dialect).alias_or_name}
3278        for i, join in enumerate(this.args.get("joins") or []):
3279            table = join.this
3280            normalized_table = table.copy()
3281            normalized_table.meta["maybe_column"] = True
3282            normalized_table = _norm(normalized_table, dialect=self.dialect)
3283
3284            if isinstance(table, exp.Table) and not join.args.get("on"):
3285                if normalized_table.parts[0].name in refs:
3286                    table_as_column = table.to_column()
3287                    unnest = exp.Unnest(expressions=[table_as_column])
3288
3289                    # Table.to_column creates a parent Alias node that we want to convert to
3290                    # a TableAlias and attach to the Unnest, so it matches the parser's output
3291                    if isinstance(table.args.get("alias"), exp.TableAlias):
3292                        table_as_column.replace(table_as_column.this)
3293                        exp.alias_(unnest, None, table=[table.args["alias"].this], copy=False)
3294
3295                    table.replace(unnest)
3296
3297            refs.add(normalized_table.alias_or_name)
3298
3299        return this
3300
3301    def _parse_query_modifiers(
3302        self, this: t.Optional[exp.Expression]
3303    ) -> t.Optional[exp.Expression]:
3304        if isinstance(this, (exp.Query, exp.Table)):
3305            for join in self._parse_joins():
3306                this.append("joins", join)
3307            for lateral in iter(self._parse_lateral, None):
3308                this.append("laterals", lateral)
3309
3310            while True:
3311                if self._match_set(self.QUERY_MODIFIER_PARSERS, advance=False):
3312                    parser = self.QUERY_MODIFIER_PARSERS[self._curr.token_type]
3313                    key, expression = parser(self)
3314
3315                    if expression:
3316                        this.set(key, expression)
3317                        if key == "limit":
3318                            offset = expression.args.pop("offset", None)
3319
3320                            if offset:
3321                                offset = exp.Offset(expression=offset)
3322                                this.set("offset", offset)
3323
3324                                limit_by_expressions = expression.expressions
3325                                expression.set("expressions", None)
3326                                offset.set("expressions", limit_by_expressions)
3327                        continue
3328                break
3329
3330        if self.SUPPORTS_IMPLICIT_UNNEST and this and this.args.get("from"):
3331            this = self._implicit_unnests_to_explicit(this)
3332
3333        return this
3334
3335    def _parse_hint_fallback_to_string(self) -> t.Optional[exp.Hint]:
3336        start = self._curr
3337        while self._curr:
3338            self._advance()
3339
3340        end = self._tokens[self._index - 1]
3341        return exp.Hint(expressions=[self._find_sql(start, end)])
3342
3343    def _parse_hint_function_call(self) -> t.Optional[exp.Expression]:
3344        return self._parse_function_call()
3345
3346    def _parse_hint_body(self) -> t.Optional[exp.Hint]:
3347        start_index = self._index
3348        should_fallback_to_string = False
3349
3350        hints = []
3351        try:
3352            for hint in iter(
3353                lambda: self._parse_csv(
3354                    lambda: self._parse_hint_function_call() or self._parse_var(upper=True),
3355                ),
3356                [],
3357            ):
3358                hints.extend(hint)
3359        except ParseError:
3360            should_fallback_to_string = True
3361
3362        if should_fallback_to_string or self._curr:
3363            self._retreat(start_index)
3364            return self._parse_hint_fallback_to_string()
3365
3366        return self.expression(exp.Hint, expressions=hints)
3367
3368    def _parse_hint(self) -> t.Optional[exp.Hint]:
3369        if self._match(TokenType.HINT) and self._prev_comments:
3370            return exp.maybe_parse(self._prev_comments[0], into=exp.Hint, dialect=self.dialect)
3371
3372        return None
3373
3374    def _parse_into(self) -> t.Optional[exp.Into]:
3375        if not self._match(TokenType.INTO):
3376            return None
3377
3378        temp = self._match(TokenType.TEMPORARY)
3379        unlogged = self._match_text_seq("UNLOGGED")
3380        self._match(TokenType.TABLE)
3381
3382        return self.expression(
3383            exp.Into, this=self._parse_table(schema=True), temporary=temp, unlogged=unlogged
3384        )
3385
3386    def _parse_from(
3387        self, joins: bool = False, skip_from_token: bool = False
3388    ) -> t.Optional[exp.From]:
3389        if not skip_from_token and not self._match(TokenType.FROM):
3390            return None
3391
3392        return self.expression(
3393            exp.From, comments=self._prev_comments, this=self._parse_table(joins=joins)
3394        )
3395
3396    def _parse_match_recognize_measure(self) -> exp.MatchRecognizeMeasure:
3397        return self.expression(
3398            exp.MatchRecognizeMeasure,
3399            window_frame=self._match_texts(("FINAL", "RUNNING")) and self._prev.text.upper(),
3400            this=self._parse_expression(),
3401        )
3402
3403    def _parse_match_recognize(self) -> t.Optional[exp.MatchRecognize]:
3404        if not self._match(TokenType.MATCH_RECOGNIZE):
3405            return None
3406
3407        self._match_l_paren()
3408
3409        partition = self._parse_partition_by()
3410        order = self._parse_order()
3411
3412        measures = (
3413            self._parse_csv(self._parse_match_recognize_measure)
3414            if self._match_text_seq("MEASURES")
3415            else None
3416        )
3417
3418        if self._match_text_seq("ONE", "ROW", "PER", "MATCH"):
3419            rows = exp.var("ONE ROW PER MATCH")
3420        elif self._match_text_seq("ALL", "ROWS", "PER", "MATCH"):
3421            text = "ALL ROWS PER MATCH"
3422            if self._match_text_seq("SHOW", "EMPTY", "MATCHES"):
3423                text += " SHOW EMPTY MATCHES"
3424            elif self._match_text_seq("OMIT", "EMPTY", "MATCHES"):
3425                text += " OMIT EMPTY MATCHES"
3426            elif self._match_text_seq("WITH", "UNMATCHED", "ROWS"):
3427                text += " WITH UNMATCHED ROWS"
3428            rows = exp.var(text)
3429        else:
3430            rows = None
3431
3432        if self._match_text_seq("AFTER", "MATCH", "SKIP"):
3433            text = "AFTER MATCH SKIP"
3434            if self._match_text_seq("PAST", "LAST", "ROW"):
3435                text += " PAST LAST ROW"
3436            elif self._match_text_seq("TO", "NEXT", "ROW"):
3437                text += " TO NEXT ROW"
3438            elif self._match_text_seq("TO", "FIRST"):
3439                text += f" TO FIRST {self._advance_any().text}"  # type: ignore
3440            elif self._match_text_seq("TO", "LAST"):
3441                text += f" TO LAST {self._advance_any().text}"  # type: ignore
3442            after = exp.var(text)
3443        else:
3444            after = None
3445
3446        if self._match_text_seq("PATTERN"):
3447            self._match_l_paren()
3448
3449            if not self._curr:
3450                self.raise_error("Expecting )", self._curr)
3451
3452            paren = 1
3453            start = self._curr
3454
3455            while self._curr and paren > 0:
3456                if self._curr.token_type == TokenType.L_PAREN:
3457                    paren += 1
3458                if self._curr.token_type == TokenType.R_PAREN:
3459                    paren -= 1
3460
3461                end = self._prev
3462                self._advance()
3463
3464            if paren > 0:
3465                self.raise_error("Expecting )", self._curr)
3466
3467            pattern = exp.var(self._find_sql(start, end))
3468        else:
3469            pattern = None
3470
3471        define = (
3472            self._parse_csv(self._parse_name_as_expression)
3473            if self._match_text_seq("DEFINE")
3474            else None
3475        )
3476
3477        self._match_r_paren()
3478
3479        return self.expression(
3480            exp.MatchRecognize,
3481            partition_by=partition,
3482            order=order,
3483            measures=measures,
3484            rows=rows,
3485            after=after,
3486            pattern=pattern,
3487            define=define,
3488            alias=self._parse_table_alias(),
3489        )
3490
3491    def _parse_lateral(self) -> t.Optional[exp.Lateral]:
3492        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY)
3493        if not cross_apply and self._match_pair(TokenType.OUTER, TokenType.APPLY):
3494            cross_apply = False
3495
3496        if cross_apply is not None:
3497            this = self._parse_select(table=True)
3498            view = None
3499            outer = None
3500        elif self._match(TokenType.LATERAL):
3501            this = self._parse_select(table=True)
3502            view = self._match(TokenType.VIEW)
3503            outer = self._match(TokenType.OUTER)
3504        else:
3505            return None
3506
3507        if not this:
3508            this = (
3509                self._parse_unnest()
3510                or self._parse_function()
3511                or self._parse_id_var(any_token=False)
3512            )
3513
3514            while self._match(TokenType.DOT):
3515                this = exp.Dot(
3516                    this=this,
3517                    expression=self._parse_function() or self._parse_id_var(any_token=False),
3518                )
3519
3520        if view:
3521            table = self._parse_id_var(any_token=False)
3522            columns = self._parse_csv(self._parse_id_var) if self._match(TokenType.ALIAS) else []
3523            table_alias: t.Optional[exp.TableAlias] = self.expression(
3524                exp.TableAlias, this=table, columns=columns
3525            )
3526        elif isinstance(this, (exp.Subquery, exp.Unnest)) and this.alias:
3527            # We move the alias from the lateral's child node to the lateral itself
3528            table_alias = this.args["alias"].pop()
3529        else:
3530            table_alias = self._parse_table_alias()
3531
3532        return self.expression(
3533            exp.Lateral,
3534            this=this,
3535            view=view,
3536            outer=outer,
3537            alias=table_alias,
3538            cross_apply=cross_apply,
3539        )
3540
3541    def _parse_join_parts(
3542        self,
3543    ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
3544        return (
3545            self._match_set(self.JOIN_METHODS) and self._prev,
3546            self._match_set(self.JOIN_SIDES) and self._prev,
3547            self._match_set(self.JOIN_KINDS) and self._prev,
3548        )
3549
3550    def _parse_using_identifiers(self) -> t.List[exp.Expression]:
3551        def _parse_column_as_identifier() -> t.Optional[exp.Expression]:
3552            this = self._parse_column()
3553            if isinstance(this, exp.Column):
3554                return this.this
3555            return this
3556
3557        return self._parse_wrapped_csv(_parse_column_as_identifier, optional=True)
3558
3559    def _parse_join(
3560        self, skip_join_token: bool = False, parse_bracket: bool = False
3561    ) -> t.Optional[exp.Join]:
3562        if self._match(TokenType.COMMA):
3563            return self.expression(exp.Join, this=self._parse_table())
3564
3565        index = self._index
3566        method, side, kind = self._parse_join_parts()
3567        hint = self._prev.text if self._match_texts(self.JOIN_HINTS) else None
3568        join = self._match(TokenType.JOIN) or (kind and kind.token_type == TokenType.STRAIGHT_JOIN)
3569
3570        if not skip_join_token and not join:
3571            self._retreat(index)
3572            kind = None
3573            method = None
3574            side = None
3575
3576        outer_apply = self._match_pair(TokenType.OUTER, TokenType.APPLY, False)
3577        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY, False)
3578
3579        if not skip_join_token and not join and not outer_apply and not cross_apply:
3580            return None
3581
3582        kwargs: t.Dict[str, t.Any] = {"this": self._parse_table(parse_bracket=parse_bracket)}
3583        if kind and kind.token_type == TokenType.ARRAY and self._match(TokenType.COMMA):
3584            kwargs["expressions"] = self._parse_csv(
3585                lambda: self._parse_table(parse_bracket=parse_bracket)
3586            )
3587
3588        if method:
3589            kwargs["method"] = method.text
3590        if side:
3591            kwargs["side"] = side.text
3592        if kind:
3593            kwargs["kind"] = kind.text
3594        if hint:
3595            kwargs["hint"] = hint
3596
3597        if self._match(TokenType.MATCH_CONDITION):
3598            kwargs["match_condition"] = self._parse_wrapped(self._parse_comparison)
3599
3600        if self._match(TokenType.ON):
3601            kwargs["on"] = self._parse_assignment()
3602        elif self._match(TokenType.USING):
3603            kwargs["using"] = self._parse_using_identifiers()
3604        elif (
3605            not (outer_apply or cross_apply)
3606            and not isinstance(kwargs["this"], exp.Unnest)
3607            and not (kind and kind.token_type in (TokenType.CROSS, TokenType.ARRAY))
3608        ):
3609            index = self._index
3610            joins: t.Optional[list] = list(self._parse_joins())
3611
3612            if joins and self._match(TokenType.ON):
3613                kwargs["on"] = self._parse_assignment()
3614            elif joins and self._match(TokenType.USING):
3615                kwargs["using"] = self._parse_using_identifiers()
3616            else:
3617                joins = None
3618                self._retreat(index)
3619
3620            kwargs["this"].set("joins", joins if joins else None)
3621
3622        comments = [c for token in (method, side, kind) if token for c in token.comments]
3623        return self.expression(exp.Join, comments=comments, **kwargs)
3624
3625    def _parse_opclass(self) -> t.Optional[exp.Expression]:
3626        this = self._parse_assignment()
3627
3628        if self._match_texts(self.OPCLASS_FOLLOW_KEYWORDS, advance=False):
3629            return this
3630
3631        if not self._match_set(self.OPTYPE_FOLLOW_TOKENS, advance=False):
3632            return self.expression(exp.Opclass, this=this, expression=self._parse_table_parts())
3633
3634        return this
3635
3636    def _parse_index_params(self) -> exp.IndexParameters:
3637        using = self._parse_var(any_token=True) if self._match(TokenType.USING) else None
3638
3639        if self._match(TokenType.L_PAREN, advance=False):
3640            columns = self._parse_wrapped_csv(self._parse_with_operator)
3641        else:
3642            columns = None
3643
3644        include = self._parse_wrapped_id_vars() if self._match_text_seq("INCLUDE") else None
3645        partition_by = self._parse_partition_by()
3646        with_storage = self._match(TokenType.WITH) and self._parse_wrapped_properties()
3647        tablespace = (
3648            self._parse_var(any_token=True)
3649            if self._match_text_seq("USING", "INDEX", "TABLESPACE")
3650            else None
3651        )
3652        where = self._parse_where()
3653
3654        on = self._parse_field() if self._match(TokenType.ON) else None
3655
3656        return self.expression(
3657            exp.IndexParameters,
3658            using=using,
3659            columns=columns,
3660            include=include,
3661            partition_by=partition_by,
3662            where=where,
3663            with_storage=with_storage,
3664            tablespace=tablespace,
3665            on=on,
3666        )
3667
3668    def _parse_index(
3669        self, index: t.Optional[exp.Expression] = None, anonymous: bool = False
3670    ) -> t.Optional[exp.Index]:
3671        if index or anonymous:
3672            unique = None
3673            primary = None
3674            amp = None
3675
3676            self._match(TokenType.ON)
3677            self._match(TokenType.TABLE)  # hive
3678            table = self._parse_table_parts(schema=True)
3679        else:
3680            unique = self._match(TokenType.UNIQUE)
3681            primary = self._match_text_seq("PRIMARY")
3682            amp = self._match_text_seq("AMP")
3683
3684            if not self._match(TokenType.INDEX):
3685                return None
3686
3687            index = self._parse_id_var()
3688            table = None
3689
3690        params = self._parse_index_params()
3691
3692        return self.expression(
3693            exp.Index,
3694            this=index,
3695            table=table,
3696            unique=unique,
3697            primary=primary,
3698            amp=amp,
3699            params=params,
3700        )
3701
3702    def _parse_table_hints(self) -> t.Optional[t.List[exp.Expression]]:
3703        hints: t.List[exp.Expression] = []
3704        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
3705            # https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
3706            hints.append(
3707                self.expression(
3708                    exp.WithTableHint,
3709                    expressions=self._parse_csv(
3710                        lambda: self._parse_function() or self._parse_var(any_token=True)
3711                    ),
3712                )
3713            )
3714            self._match_r_paren()
3715        else:
3716            # https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
3717            while self._match_set(self.TABLE_INDEX_HINT_TOKENS):
3718                hint = exp.IndexTableHint(this=self._prev.text.upper())
3719
3720                self._match_set((TokenType.INDEX, TokenType.KEY))
3721                if self._match(TokenType.FOR):
3722                    hint.set("target", self._advance_any() and self._prev.text.upper())
3723
3724                hint.set("expressions", self._parse_wrapped_id_vars())
3725                hints.append(hint)
3726
3727        return hints or None
3728
3729    def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
3730        return (
3731            (not schema and self._parse_function(optional_parens=False))
3732            or self._parse_id_var(any_token=False)
3733            or self._parse_string_as_identifier()
3734            or self._parse_placeholder()
3735        )
3736
3737    def _parse_table_parts(
3738        self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
3739    ) -> exp.Table:
3740        catalog = None
3741        db = None
3742        table: t.Optional[exp.Expression | str] = self._parse_table_part(schema=schema)
3743
3744        while self._match(TokenType.DOT):
3745            if catalog:
3746                # This allows nesting the table in arbitrarily many dot expressions if needed
3747                table = self.expression(
3748                    exp.Dot, this=table, expression=self._parse_table_part(schema=schema)
3749                )
3750            else:
3751                catalog = db
3752                db = table
3753                # "" used for tsql FROM a..b case
3754                table = self._parse_table_part(schema=schema) or ""
3755
3756        if (
3757            wildcard
3758            and self._is_connected()
3759            and (isinstance(table, exp.Identifier) or not table)
3760            and self._match(TokenType.STAR)
3761        ):
3762            if isinstance(table, exp.Identifier):
3763                table.args["this"] += "*"
3764            else:
3765                table = exp.Identifier(this="*")
3766
3767        # We bubble up comments from the Identifier to the Table
3768        comments = table.pop_comments() if isinstance(table, exp.Expression) else None
3769
3770        if is_db_reference:
3771            catalog = db
3772            db = table
3773            table = None
3774
3775        if not table and not is_db_reference:
3776            self.raise_error(f"Expected table name but got {self._curr}")
3777        if not db and is_db_reference:
3778            self.raise_error(f"Expected database name but got {self._curr}")
3779
3780        table = self.expression(
3781            exp.Table,
3782            comments=comments,
3783            this=table,
3784            db=db,
3785            catalog=catalog,
3786        )
3787
3788        changes = self._parse_changes()
3789        if changes:
3790            table.set("changes", changes)
3791
3792        at_before = self._parse_historical_data()
3793        if at_before:
3794            table.set("when", at_before)
3795
3796        pivots = self._parse_pivots()
3797        if pivots:
3798            table.set("pivots", pivots)
3799
3800        return table
3801
3802    def _parse_table(
3803        self,
3804        schema: bool = False,
3805        joins: bool = False,
3806        alias_tokens: t.Optional[t.Collection[TokenType]] = None,
3807        parse_bracket: bool = False,
3808        is_db_reference: bool = False,
3809        parse_partition: bool = False,
3810    ) -> t.Optional[exp.Expression]:
3811        lateral = self._parse_lateral()
3812        if lateral:
3813            return lateral
3814
3815        unnest = self._parse_unnest()
3816        if unnest:
3817            return unnest
3818
3819        values = self._parse_derived_table_values()
3820        if values:
3821            return values
3822
3823        subquery = self._parse_select(table=True)
3824        if subquery:
3825            if not subquery.args.get("pivots"):
3826                subquery.set("pivots", self._parse_pivots())
3827            return subquery
3828
3829        bracket = parse_bracket and self._parse_bracket(None)
3830        bracket = self.expression(exp.Table, this=bracket) if bracket else None
3831
3832        rows_from = self._match_text_seq("ROWS", "FROM") and self._parse_wrapped_csv(
3833            self._parse_table
3834        )
3835        rows_from = self.expression(exp.Table, rows_from=rows_from) if rows_from else None
3836
3837        only = self._match(TokenType.ONLY)
3838
3839        this = t.cast(
3840            exp.Expression,
3841            bracket
3842            or rows_from
3843            or self._parse_bracket(
3844                self._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
3845            ),
3846        )
3847
3848        if only:
3849            this.set("only", only)
3850
3851        # Postgres supports a wildcard (table) suffix operator, which is a no-op in this context
3852        self._match_text_seq("*")
3853
3854        parse_partition = parse_partition or self.SUPPORTS_PARTITION_SELECTION
3855        if parse_partition and self._match(TokenType.PARTITION, advance=False):
3856            this.set("partition", self._parse_partition())
3857
3858        if schema:
3859            return self._parse_schema(this=this)
3860
3861        version = self._parse_version()
3862
3863        if version:
3864            this.set("version", version)
3865
3866        if self.dialect.ALIAS_POST_TABLESAMPLE:
3867            this.set("sample", self._parse_table_sample())
3868
3869        alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
3870        if alias:
3871            this.set("alias", alias)
3872
3873        if isinstance(this, exp.Table) and self._match_text_seq("AT"):
3874            return self.expression(
3875                exp.AtIndex, this=this.to_column(copy=False), expression=self._parse_id_var()
3876            )
3877
3878        this.set("hints", self._parse_table_hints())
3879
3880        if not this.args.get("pivots"):
3881            this.set("pivots", self._parse_pivots())
3882
3883        if not self.dialect.ALIAS_POST_TABLESAMPLE:
3884            this.set("sample", self._parse_table_sample())
3885
3886        if joins:
3887            for join in self._parse_joins():
3888                this.append("joins", join)
3889
3890        if self._match_pair(TokenType.WITH, TokenType.ORDINALITY):
3891            this.set("ordinality", True)
3892            this.set("alias", self._parse_table_alias())
3893
3894        return this
3895
3896    def _parse_version(self) -> t.Optional[exp.Version]:
3897        if self._match(TokenType.TIMESTAMP_SNAPSHOT):
3898            this = "TIMESTAMP"
3899        elif self._match(TokenType.VERSION_SNAPSHOT):
3900            this = "VERSION"
3901        else:
3902            return None
3903
3904        if self._match_set((TokenType.FROM, TokenType.BETWEEN)):
3905            kind = self._prev.text.upper()
3906            start = self._parse_bitwise()
3907            self._match_texts(("TO", "AND"))
3908            end = self._parse_bitwise()
3909            expression: t.Optional[exp.Expression] = self.expression(
3910                exp.Tuple, expressions=[start, end]
3911            )
3912        elif self._match_text_seq("CONTAINED", "IN"):
3913            kind = "CONTAINED IN"
3914            expression = self.expression(
3915                exp.Tuple, expressions=self._parse_wrapped_csv(self._parse_bitwise)
3916            )
3917        elif self._match(TokenType.ALL):
3918            kind = "ALL"
3919            expression = None
3920        else:
3921            self._match_text_seq("AS", "OF")
3922            kind = "AS OF"
3923            expression = self._parse_type()
3924
3925        return self.expression(exp.Version, this=this, expression=expression, kind=kind)
3926
3927    def _parse_historical_data(self) -> t.Optional[exp.HistoricalData]:
3928        # https://docs.snowflake.com/en/sql-reference/constructs/at-before
3929        index = self._index
3930        historical_data = None
3931        if self._match_texts(self.HISTORICAL_DATA_PREFIX):
3932            this = self._prev.text.upper()
3933            kind = (
3934                self._match(TokenType.L_PAREN)
3935                and self._match_texts(self.HISTORICAL_DATA_KIND)
3936                and self._prev.text.upper()
3937            )
3938            expression = self._match(TokenType.FARROW) and self._parse_bitwise()
3939
3940            if expression:
3941                self._match_r_paren()
3942                historical_data = self.expression(
3943                    exp.HistoricalData, this=this, kind=kind, expression=expression
3944                )
3945            else:
3946                self._retreat(index)
3947
3948        return historical_data
3949
3950    def _parse_changes(self) -> t.Optional[exp.Changes]:
3951        if not self._match_text_seq("CHANGES", "(", "INFORMATION", "=>"):
3952            return None
3953
3954        information = self._parse_var(any_token=True)
3955        self._match_r_paren()
3956
3957        return self.expression(
3958            exp.Changes,
3959            information=information,
3960            at_before=self._parse_historical_data(),
3961            end=self._parse_historical_data(),
3962        )
3963
3964    def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
3965        if not self._match(TokenType.UNNEST):
3966            return None
3967
3968        expressions = self._parse_wrapped_csv(self._parse_equality)
3969        offset = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
3970
3971        alias = self._parse_table_alias() if with_alias else None
3972
3973        if alias:
3974            if self.dialect.UNNEST_COLUMN_ONLY:
3975                if alias.args.get("columns"):
3976                    self.raise_error("Unexpected extra column alias in unnest.")
3977
3978                alias.set("columns", [alias.this])
3979                alias.set("this", None)
3980
3981            columns = alias.args.get("columns") or []
3982            if offset and len(expressions) < len(columns):
3983                offset = columns.pop()
3984
3985        if not offset and self._match_pair(TokenType.WITH, TokenType.OFFSET):
3986            self._match(TokenType.ALIAS)
3987            offset = self._parse_id_var(
3988                any_token=False, tokens=self.UNNEST_OFFSET_ALIAS_TOKENS
3989            ) or exp.to_identifier("offset")
3990
3991        return self.expression(exp.Unnest, expressions=expressions, alias=alias, offset=offset)
3992
3993    def _parse_derived_table_values(self) -> t.Optional[exp.Values]:
3994        is_derived = self._match_pair(TokenType.L_PAREN, TokenType.VALUES)
3995        if not is_derived and not (
3996            # ClickHouse's `FORMAT Values` is equivalent to `VALUES`
3997            self._match_text_seq("VALUES") or self._match_text_seq("FORMAT", "VALUES")
3998        ):
3999            return None
4000
4001        expressions = self._parse_csv(self._parse_value)
4002        alias = self._parse_table_alias()
4003
4004        if is_derived:
4005            self._match_r_paren()
4006
4007        return self.expression(
4008            exp.Values, expressions=expressions, alias=alias or self._parse_table_alias()
4009        )
4010
4011    def _parse_table_sample(self, as_modifier: bool = False) -> t.Optional[exp.TableSample]:
4012        if not self._match(TokenType.TABLE_SAMPLE) and not (
4013            as_modifier and self._match_text_seq("USING", "SAMPLE")
4014        ):
4015            return None
4016
4017        bucket_numerator = None
4018        bucket_denominator = None
4019        bucket_field = None
4020        percent = None
4021        size = None
4022        seed = None
4023
4024        method = self._parse_var(tokens=(TokenType.ROW,), upper=True)
4025        matched_l_paren = self._match(TokenType.L_PAREN)
4026
4027        if self.TABLESAMPLE_CSV:
4028            num = None
4029            expressions = self._parse_csv(self._parse_primary)
4030        else:
4031            expressions = None
4032            num = (
4033                self._parse_factor()
4034                if self._match(TokenType.NUMBER, advance=False)
4035                else self._parse_primary() or self._parse_placeholder()
4036            )
4037
4038        if self._match_text_seq("BUCKET"):
4039            bucket_numerator = self._parse_number()
4040            self._match_text_seq("OUT", "OF")
4041            bucket_denominator = bucket_denominator = self._parse_number()
4042            self._match(TokenType.ON)
4043            bucket_field = self._parse_field()
4044        elif self._match_set((TokenType.PERCENT, TokenType.MOD)):
4045            percent = num
4046        elif self._match(TokenType.ROWS) or not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
4047            size = num
4048        else:
4049            percent = num
4050
4051        if matched_l_paren:
4052            self._match_r_paren()
4053
4054        if self._match(TokenType.L_PAREN):
4055            method = self._parse_var(upper=True)
4056            seed = self._match(TokenType.COMMA) and self._parse_number()
4057            self._match_r_paren()
4058        elif self._match_texts(("SEED", "REPEATABLE")):
4059            seed = self._parse_wrapped(self._parse_number)
4060
4061        if not method and self.DEFAULT_SAMPLING_METHOD:
4062            method = exp.var(self.DEFAULT_SAMPLING_METHOD)
4063
4064        return self.expression(
4065            exp.TableSample,
4066            expressions=expressions,
4067            method=method,
4068            bucket_numerator=bucket_numerator,
4069            bucket_denominator=bucket_denominator,
4070            bucket_field=bucket_field,
4071            percent=percent,
4072            size=size,
4073            seed=seed,
4074        )
4075
4076    def _parse_pivots(self) -> t.Optional[t.List[exp.Pivot]]:
4077        return list(iter(self._parse_pivot, None)) or None
4078
4079    def _parse_joins(self) -> t.Iterator[exp.Join]:
4080        return iter(self._parse_join, None)
4081
4082    def _parse_unpivot_columns(self) -> t.Optional[exp.UnpivotColumns]:
4083        if not self._match(TokenType.INTO):
4084            return None
4085
4086        return self.expression(
4087            exp.UnpivotColumns,
4088            this=self._match_text_seq("NAME") and self._parse_column(),
4089            expressions=self._match_text_seq("VALUE") and self._parse_csv(self._parse_column),
4090        )
4091
4092    # https://duckdb.org/docs/sql/statements/pivot
4093    def _parse_simplified_pivot(self, is_unpivot: t.Optional[bool] = None) -> exp.Pivot:
4094        def _parse_on() -> t.Optional[exp.Expression]:
4095            this = self._parse_bitwise()
4096
4097            if self._match(TokenType.IN):
4098                # PIVOT ... ON col IN (row_val1, row_val2)
4099                return self._parse_in(this)
4100            if self._match(TokenType.ALIAS, advance=False):
4101                # UNPIVOT ... ON (col1, col2, col3) AS row_val
4102                return self._parse_alias(this)
4103
4104            return this
4105
4106        this = self._parse_table()
4107        expressions = self._match(TokenType.ON) and self._parse_csv(_parse_on)
4108        into = self._parse_unpivot_columns()
4109        using = self._match(TokenType.USING) and self._parse_csv(
4110            lambda: self._parse_alias(self._parse_function())
4111        )
4112        group = self._parse_group()
4113
4114        return self.expression(
4115            exp.Pivot,
4116            this=this,
4117            expressions=expressions,
4118            using=using,
4119            group=group,
4120            unpivot=is_unpivot,
4121            into=into,
4122        )
4123
4124    def _parse_pivot_in(self) -> exp.In | exp.PivotAny:
4125        def _parse_aliased_expression() -> t.Optional[exp.Expression]:
4126            this = self._parse_select_or_expression()
4127
4128            self._match(TokenType.ALIAS)
4129            alias = self._parse_bitwise()
4130            if alias:
4131                if isinstance(alias, exp.Column) and not alias.db:
4132                    alias = alias.this
4133                return self.expression(exp.PivotAlias, this=this, alias=alias)
4134
4135            return this
4136
4137        value = self._parse_column()
4138
4139        if not self._match_pair(TokenType.IN, TokenType.L_PAREN):
4140            self.raise_error("Expecting IN (")
4141
4142        if self._match(TokenType.ANY):
4143            exprs: t.List[exp.Expression] = ensure_list(exp.PivotAny(this=self._parse_order()))
4144        else:
4145            exprs = self._parse_csv(_parse_aliased_expression)
4146
4147        self._match_r_paren()
4148        return self.expression(exp.In, this=value, expressions=exprs)
4149
4150    def _parse_pivot(self) -> t.Optional[exp.Pivot]:
4151        index = self._index
4152        include_nulls = None
4153
4154        if self._match(TokenType.PIVOT):
4155            unpivot = False
4156        elif self._match(TokenType.UNPIVOT):
4157            unpivot = True
4158
4159            # https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-unpivot.html#syntax
4160            if self._match_text_seq("INCLUDE", "NULLS"):
4161                include_nulls = True
4162            elif self._match_text_seq("EXCLUDE", "NULLS"):
4163                include_nulls = False
4164        else:
4165            return None
4166
4167        expressions = []
4168
4169        if not self._match(TokenType.L_PAREN):
4170            self._retreat(index)
4171            return None
4172
4173        if unpivot:
4174            expressions = self._parse_csv(self._parse_column)
4175        else:
4176            expressions = self._parse_csv(lambda: self._parse_alias(self._parse_function()))
4177
4178        if not expressions:
4179            self.raise_error("Failed to parse PIVOT's aggregation list")
4180
4181        if not self._match(TokenType.FOR):
4182            self.raise_error("Expecting FOR")
4183
4184        field = self._parse_pivot_in()
4185        default_on_null = self._match_text_seq("DEFAULT", "ON", "NULL") and self._parse_wrapped(
4186            self._parse_bitwise
4187        )
4188
4189        self._match_r_paren()
4190
4191        pivot = self.expression(
4192            exp.Pivot,
4193            expressions=expressions,
4194            field=field,
4195            unpivot=unpivot,
4196            include_nulls=include_nulls,
4197            default_on_null=default_on_null,
4198        )
4199
4200        if not self._match_set((TokenType.PIVOT, TokenType.UNPIVOT), advance=False):
4201            pivot.set("alias", self._parse_table_alias())
4202
4203        if not unpivot:
4204            names = self._pivot_column_names(t.cast(t.List[exp.Expression], expressions))
4205
4206            columns: t.List[exp.Expression] = []
4207            for fld in pivot.args["field"].expressions:
4208                field_name = fld.sql() if self.IDENTIFY_PIVOT_STRINGS else fld.alias_or_name
4209                for name in names:
4210                    if self.PREFIXED_PIVOT_COLUMNS:
4211                        name = f"{name}_{field_name}" if name else field_name
4212                    else:
4213                        name = f"{field_name}_{name}" if name else field_name
4214
4215                    columns.append(exp.to_identifier(name))
4216
4217            pivot.set("columns", columns)
4218
4219        return pivot
4220
4221    def _pivot_column_names(self, aggregations: t.List[exp.Expression]) -> t.List[str]:
4222        return [agg.alias for agg in aggregations]
4223
4224    def _parse_prewhere(self, skip_where_token: bool = False) -> t.Optional[exp.PreWhere]:
4225        if not skip_where_token and not self._match(TokenType.PREWHERE):
4226            return None
4227
4228        return self.expression(
4229            exp.PreWhere, comments=self._prev_comments, this=self._parse_assignment()
4230        )
4231
4232    def _parse_where(self, skip_where_token: bool = False) -> t.Optional[exp.Where]:
4233        if not skip_where_token and not self._match(TokenType.WHERE):
4234            return None
4235
4236        return self.expression(
4237            exp.Where, comments=self._prev_comments, this=self._parse_assignment()
4238        )
4239
4240    def _parse_group(self, skip_group_by_token: bool = False) -> t.Optional[exp.Group]:
4241        if not skip_group_by_token and not self._match(TokenType.GROUP_BY):
4242            return None
4243
4244        elements: t.Dict[str, t.Any] = defaultdict(list)
4245
4246        if self._match(TokenType.ALL):
4247            elements["all"] = True
4248        elif self._match(TokenType.DISTINCT):
4249            elements["all"] = False
4250
4251        while True:
4252            index = self._index
4253
4254            elements["expressions"].extend(
4255                self._parse_csv(
4256                    lambda: None
4257                    if self._match_set((TokenType.CUBE, TokenType.ROLLUP), advance=False)
4258                    else self._parse_assignment()
4259                )
4260            )
4261
4262            before_with_index = self._index
4263            with_prefix = self._match(TokenType.WITH)
4264
4265            if self._match(TokenType.ROLLUP):
4266                elements["rollup"].append(
4267                    self._parse_cube_or_rollup(exp.Rollup, with_prefix=with_prefix)
4268                )
4269            elif self._match(TokenType.CUBE):
4270                elements["cube"].append(
4271                    self._parse_cube_or_rollup(exp.Cube, with_prefix=with_prefix)
4272                )
4273            elif self._match(TokenType.GROUPING_SETS):
4274                elements["grouping_sets"].append(
4275                    self.expression(
4276                        exp.GroupingSets,
4277                        expressions=self._parse_wrapped_csv(self._parse_grouping_set),
4278                    )
4279                )
4280            elif self._match_text_seq("TOTALS"):
4281                elements["totals"] = True  # type: ignore
4282
4283            if before_with_index <= self._index <= before_with_index + 1:
4284                self._retreat(before_with_index)
4285                break
4286
4287            if index == self._index:
4288                break
4289
4290        return self.expression(exp.Group, **elements)  # type: ignore
4291
4292    def _parse_cube_or_rollup(self, kind: t.Type[E], with_prefix: bool = False) -> E:
4293        return self.expression(
4294            kind, expressions=[] if with_prefix else self._parse_wrapped_csv(self._parse_column)
4295        )
4296
4297    def _parse_grouping_set(self) -> t.Optional[exp.Expression]:
4298        if self._match(TokenType.L_PAREN):
4299            grouping_set = self._parse_csv(self._parse_column)
4300            self._match_r_paren()
4301            return self.expression(exp.Tuple, expressions=grouping_set)
4302
4303        return self._parse_column()
4304
4305    def _parse_having(self, skip_having_token: bool = False) -> t.Optional[exp.Having]:
4306        if not skip_having_token and not self._match(TokenType.HAVING):
4307            return None
4308        return self.expression(exp.Having, this=self._parse_assignment())
4309
4310    def _parse_qualify(self) -> t.Optional[exp.Qualify]:
4311        if not self._match(TokenType.QUALIFY):
4312            return None
4313        return self.expression(exp.Qualify, this=self._parse_assignment())
4314
4315    def _parse_connect(self, skip_start_token: bool = False) -> t.Optional[exp.Connect]:
4316        if skip_start_token:
4317            start = None
4318        elif self._match(TokenType.START_WITH):
4319            start = self._parse_assignment()
4320        else:
4321            return None
4322
4323        self._match(TokenType.CONNECT_BY)
4324        nocycle = self._match_text_seq("NOCYCLE")
4325        self.NO_PAREN_FUNCTION_PARSERS["PRIOR"] = lambda self: self.expression(
4326            exp.Prior, this=self._parse_bitwise()
4327        )
4328        connect = self._parse_assignment()
4329        self.NO_PAREN_FUNCTION_PARSERS.pop("PRIOR")
4330
4331        if not start and self._match(TokenType.START_WITH):
4332            start = self._parse_assignment()
4333
4334        return self.expression(exp.Connect, start=start, connect=connect, nocycle=nocycle)
4335
4336    def _parse_name_as_expression(self) -> t.Optional[exp.Expression]:
4337        this = self._parse_id_var(any_token=True)
4338        if self._match(TokenType.ALIAS):
4339            this = self.expression(exp.Alias, alias=this, this=self._parse_assignment())
4340        return this
4341
4342    def _parse_interpolate(self) -> t.Optional[t.List[exp.Expression]]:
4343        if self._match_text_seq("INTERPOLATE"):
4344            return self._parse_wrapped_csv(self._parse_name_as_expression)
4345        return None
4346
4347    def _parse_order(
4348        self, this: t.Optional[exp.Expression] = None, skip_order_token: bool = False
4349    ) -> t.Optional[exp.Expression]:
4350        siblings = None
4351        if not skip_order_token and not self._match(TokenType.ORDER_BY):
4352            if not self._match(TokenType.ORDER_SIBLINGS_BY):
4353                return this
4354
4355            siblings = True
4356
4357        return self.expression(
4358            exp.Order,
4359            this=this,
4360            expressions=self._parse_csv(self._parse_ordered),
4361            siblings=siblings,
4362        )
4363
4364    def _parse_sort(self, exp_class: t.Type[E], token: TokenType) -> t.Optional[E]:
4365        if not self._match(token):
4366            return None
4367        return self.expression(exp_class, expressions=self._parse_csv(self._parse_ordered))
4368
4369    def _parse_ordered(
4370        self, parse_method: t.Optional[t.Callable] = None
4371    ) -> t.Optional[exp.Ordered]:
4372        this = parse_method() if parse_method else self._parse_assignment()
4373        if not this:
4374            return None
4375
4376        if this.name.upper() == "ALL" and self.dialect.SUPPORTS_ORDER_BY_ALL:
4377            this = exp.var("ALL")
4378
4379        asc = self._match(TokenType.ASC)
4380        desc = self._match(TokenType.DESC) or (asc and False)
4381
4382        is_nulls_first = self._match_text_seq("NULLS", "FIRST")
4383        is_nulls_last = self._match_text_seq("NULLS", "LAST")
4384
4385        nulls_first = is_nulls_first or False
4386        explicitly_null_ordered = is_nulls_first or is_nulls_last
4387
4388        if (
4389            not explicitly_null_ordered
4390            and (
4391                (not desc and self.dialect.NULL_ORDERING == "nulls_are_small")
4392                or (desc and self.dialect.NULL_ORDERING != "nulls_are_small")
4393            )
4394            and self.dialect.NULL_ORDERING != "nulls_are_last"
4395        ):
4396            nulls_first = True
4397
4398        if self._match_text_seq("WITH", "FILL"):
4399            with_fill = self.expression(
4400                exp.WithFill,
4401                **{  # type: ignore
4402                    "from": self._match(TokenType.FROM) and self._parse_bitwise(),
4403                    "to": self._match_text_seq("TO") and self._parse_bitwise(),
4404                    "step": self._match_text_seq("STEP") and self._parse_bitwise(),
4405                    "interpolate": self._parse_interpolate(),
4406                },
4407            )
4408        else:
4409            with_fill = None
4410
4411        return self.expression(
4412            exp.Ordered, this=this, desc=desc, nulls_first=nulls_first, with_fill=with_fill
4413        )
4414
4415    def _parse_limit(
4416        self,
4417        this: t.Optional[exp.Expression] = None,
4418        top: bool = False,
4419        skip_limit_token: bool = False,
4420    ) -> t.Optional[exp.Expression]:
4421        if skip_limit_token or self._match(TokenType.TOP if top else TokenType.LIMIT):
4422            comments = self._prev_comments
4423            if top:
4424                limit_paren = self._match(TokenType.L_PAREN)
4425                expression = self._parse_term() if limit_paren else self._parse_number()
4426
4427                if limit_paren:
4428                    self._match_r_paren()
4429            else:
4430                expression = self._parse_term()
4431
4432            if self._match(TokenType.COMMA):
4433                offset = expression
4434                expression = self._parse_term()
4435            else:
4436                offset = None
4437
4438            limit_exp = self.expression(
4439                exp.Limit,
4440                this=this,
4441                expression=expression,
4442                offset=offset,
4443                comments=comments,
4444                expressions=self._parse_limit_by(),
4445            )
4446
4447            return limit_exp
4448
4449        if self._match(TokenType.FETCH):
4450            direction = self._match_set((TokenType.FIRST, TokenType.NEXT))
4451            direction = self._prev.text.upper() if direction else "FIRST"
4452
4453            count = self._parse_field(tokens=self.FETCH_TOKENS)
4454            percent = self._match(TokenType.PERCENT)
4455
4456            self._match_set((TokenType.ROW, TokenType.ROWS))
4457
4458            only = self._match_text_seq("ONLY")
4459            with_ties = self._match_text_seq("WITH", "TIES")
4460
4461            if only and with_ties:
4462                self.raise_error("Cannot specify both ONLY and WITH TIES in FETCH clause")
4463
4464            return self.expression(
4465                exp.Fetch,
4466                direction=direction,
4467                count=count,
4468                percent=percent,
4469                with_ties=with_ties,
4470            )
4471
4472        return this
4473
4474    def _parse_offset(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4475        if not self._match(TokenType.OFFSET):
4476            return this
4477
4478        count = self._parse_term()
4479        self._match_set((TokenType.ROW, TokenType.ROWS))
4480
4481        return self.expression(
4482            exp.Offset, this=this, expression=count, expressions=self._parse_limit_by()
4483        )
4484
4485    def _can_parse_limit_or_offset(self) -> bool:
4486        if not self._match_set(self.AMBIGUOUS_ALIAS_TOKENS, advance=False):
4487            return False
4488
4489        index = self._index
4490        result = bool(
4491            self._try_parse(self._parse_limit, retreat=True)
4492            or self._try_parse(self._parse_offset, retreat=True)
4493        )
4494        self._retreat(index)
4495        return result
4496
4497    def _parse_limit_by(self) -> t.Optional[t.List[exp.Expression]]:
4498        return self._match_text_seq("BY") and self._parse_csv(self._parse_bitwise)
4499
4500    def _parse_locks(self) -> t.List[exp.Lock]:
4501        locks = []
4502        while True:
4503            if self._match_text_seq("FOR", "UPDATE"):
4504                update = True
4505            elif self._match_text_seq("FOR", "SHARE") or self._match_text_seq(
4506                "LOCK", "IN", "SHARE", "MODE"
4507            ):
4508                update = False
4509            else:
4510                break
4511
4512            expressions = None
4513            if self._match_text_seq("OF"):
4514                expressions = self._parse_csv(lambda: self._parse_table(schema=True))
4515
4516            wait: t.Optional[bool | exp.Expression] = None
4517            if self._match_text_seq("NOWAIT"):
4518                wait = True
4519            elif self._match_text_seq("WAIT"):
4520                wait = self._parse_primary()
4521            elif self._match_text_seq("SKIP", "LOCKED"):
4522                wait = False
4523
4524            locks.append(
4525                self.expression(exp.Lock, update=update, expressions=expressions, wait=wait)
4526            )
4527
4528        return locks
4529
4530    def _parse_set_operations(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4531        while this and self._match_set(self.SET_OPERATIONS):
4532            token_type = self._prev.token_type
4533
4534            if token_type == TokenType.UNION:
4535                operation: t.Type[exp.SetOperation] = exp.Union
4536            elif token_type == TokenType.EXCEPT:
4537                operation = exp.Except
4538            else:
4539                operation = exp.Intersect
4540
4541            comments = self._prev.comments
4542
4543            if self._match(TokenType.DISTINCT):
4544                distinct: t.Optional[bool] = True
4545            elif self._match(TokenType.ALL):
4546                distinct = False
4547            else:
4548                distinct = self.dialect.SET_OP_DISTINCT_BY_DEFAULT[operation]
4549                if distinct is None:
4550                    self.raise_error(f"Expected DISTINCT or ALL for {operation.__name__}")
4551
4552            by_name = self._match_text_seq("BY", "NAME")
4553            expression = self._parse_select(nested=True, parse_set_operation=False)
4554
4555            this = self.expression(
4556                operation,
4557                comments=comments,
4558                this=this,
4559                distinct=distinct,
4560                by_name=by_name,
4561                expression=expression,
4562            )
4563
4564        if isinstance(this, exp.SetOperation) and self.MODIFIERS_ATTACHED_TO_SET_OP:
4565            expression = this.expression
4566
4567            if expression:
4568                for arg in self.SET_OP_MODIFIERS:
4569                    expr = expression.args.get(arg)
4570                    if expr:
4571                        this.set(arg, expr.pop())
4572
4573        return this
4574
4575    def _parse_expression(self) -> t.Optional[exp.Expression]:
4576        return self._parse_alias(self._parse_assignment())
4577
4578    def _parse_assignment(self) -> t.Optional[exp.Expression]:
4579        this = self._parse_disjunction()
4580        if not this and self._next and self._next.token_type in self.ASSIGNMENT:
4581            # This allows us to parse <non-identifier token> := <expr>
4582            this = exp.column(
4583                t.cast(str, self._advance_any(ignore_reserved=True) and self._prev.text)
4584            )
4585
4586        while self._match_set(self.ASSIGNMENT):
4587            if isinstance(this, exp.Column) and len(this.parts) == 1:
4588                this = this.this
4589
4590            this = self.expression(
4591                self.ASSIGNMENT[self._prev.token_type],
4592                this=this,
4593                comments=self._prev_comments,
4594                expression=self._parse_assignment(),
4595            )
4596
4597        return this
4598
4599    def _parse_disjunction(self) -> t.Optional[exp.Expression]:
4600        return self._parse_tokens(self._parse_conjunction, self.DISJUNCTION)
4601
4602    def _parse_conjunction(self) -> t.Optional[exp.Expression]:
4603        return self._parse_tokens(self._parse_equality, self.CONJUNCTION)
4604
4605    def _parse_equality(self) -> t.Optional[exp.Expression]:
4606        return self._parse_tokens(self._parse_comparison, self.EQUALITY)
4607
4608    def _parse_comparison(self) -> t.Optional[exp.Expression]:
4609        return self._parse_tokens(self._parse_range, self.COMPARISON)
4610
4611    def _parse_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4612        this = this or self._parse_bitwise()
4613        negate = self._match(TokenType.NOT)
4614
4615        if self._match_set(self.RANGE_PARSERS):
4616            expression = self.RANGE_PARSERS[self._prev.token_type](self, this)
4617            if not expression:
4618                return this
4619
4620            this = expression
4621        elif self._match(TokenType.ISNULL):
4622            this = self.expression(exp.Is, this=this, expression=exp.Null())
4623
4624        # Postgres supports ISNULL and NOTNULL for conditions.
4625        # https://blog.andreiavram.ro/postgresql-null-composite-type/
4626        if self._match(TokenType.NOTNULL):
4627            this = self.expression(exp.Is, this=this, expression=exp.Null())
4628            this = self.expression(exp.Not, this=this)
4629
4630        if negate:
4631            this = self._negate_range(this)
4632
4633        if self._match(TokenType.IS):
4634            this = self._parse_is(this)
4635
4636        return this
4637
4638    def _negate_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4639        if not this:
4640            return this
4641
4642        return self.expression(exp.Not, this=this)
4643
4644    def _parse_is(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4645        index = self._index - 1
4646        negate = self._match(TokenType.NOT)
4647
4648        if self._match_text_seq("DISTINCT", "FROM"):
4649            klass = exp.NullSafeEQ if negate else exp.NullSafeNEQ
4650            return self.expression(klass, this=this, expression=self._parse_bitwise())
4651
4652        if self._match(TokenType.JSON):
4653            kind = self._match_texts(self.IS_JSON_PREDICATE_KIND) and self._prev.text.upper()
4654
4655            if self._match_text_seq("WITH"):
4656                _with = True
4657            elif self._match_text_seq("WITHOUT"):
4658                _with = False
4659            else:
4660                _with = None
4661
4662            unique = self._match(TokenType.UNIQUE)
4663            self._match_text_seq("KEYS")
4664            expression: t.Optional[exp.Expression] = self.expression(
4665                exp.JSON, **{"this": kind, "with": _with, "unique": unique}
4666            )
4667        else:
4668            expression = self._parse_primary() or self._parse_null()
4669            if not expression:
4670                self._retreat(index)
4671                return None
4672
4673        this = self.expression(exp.Is, this=this, expression=expression)
4674        return self.expression(exp.Not, this=this) if negate else this
4675
4676    def _parse_in(self, this: t.Optional[exp.Expression], alias: bool = False) -> exp.In:
4677        unnest = self._parse_unnest(with_alias=False)
4678        if unnest:
4679            this = self.expression(exp.In, this=this, unnest=unnest)
4680        elif self._match_set((TokenType.L_PAREN, TokenType.L_BRACKET)):
4681            matched_l_paren = self._prev.token_type == TokenType.L_PAREN
4682            expressions = self._parse_csv(lambda: self._parse_select_or_expression(alias=alias))
4683
4684            if len(expressions) == 1 and isinstance(expressions[0], exp.Query):
4685                this = self.expression(exp.In, this=this, query=expressions[0].subquery(copy=False))
4686            else:
4687                this = self.expression(exp.In, this=this, expressions=expressions)
4688
4689            if matched_l_paren:
4690                self._match_r_paren(this)
4691            elif not self._match(TokenType.R_BRACKET, expression=this):
4692                self.raise_error("Expecting ]")
4693        else:
4694            this = self.expression(exp.In, this=this, field=self._parse_column())
4695
4696        return this
4697
4698    def _parse_between(self, this: t.Optional[exp.Expression]) -> exp.Between:
4699        low = self._parse_bitwise()
4700        self._match(TokenType.AND)
4701        high = self._parse_bitwise()
4702        return self.expression(exp.Between, this=this, low=low, high=high)
4703
4704    def _parse_escape(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4705        if not self._match(TokenType.ESCAPE):
4706            return this
4707        return self.expression(exp.Escape, this=this, expression=self._parse_string())
4708
4709    def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Add | exp.Interval]:
4710        index = self._index
4711
4712        if not self._match(TokenType.INTERVAL) and match_interval:
4713            return None
4714
4715        if self._match(TokenType.STRING, advance=False):
4716            this = self._parse_primary()
4717        else:
4718            this = self._parse_term()
4719
4720        if not this or (
4721            isinstance(this, exp.Column)
4722            and not this.table
4723            and not this.this.quoted
4724            and this.name.upper() == "IS"
4725        ):
4726            self._retreat(index)
4727            return None
4728
4729        unit = self._parse_function() or (
4730            not self._match(TokenType.ALIAS, advance=False)
4731            and self._parse_var(any_token=True, upper=True)
4732        )
4733
4734        # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
4735        # each INTERVAL expression into this canonical form so it's easy to transpile
4736        if this and this.is_number:
4737            this = exp.Literal.string(this.to_py())
4738        elif this and this.is_string:
4739            parts = exp.INTERVAL_STRING_RE.findall(this.name)
4740            if parts and unit:
4741                # Unconsume the eagerly-parsed unit, since the real unit was part of the string
4742                unit = None
4743                self._retreat(self._index - 1)
4744
4745            if len(parts) == 1:
4746                this = exp.Literal.string(parts[0][0])
4747                unit = self.expression(exp.Var, this=parts[0][1].upper())
4748        if self.INTERVAL_SPANS and self._match_text_seq("TO"):
4749            unit = self.expression(
4750                exp.IntervalSpan, this=unit, expression=self._parse_var(any_token=True, upper=True)
4751            )
4752
4753        interval = self.expression(exp.Interval, this=this, unit=unit)
4754
4755        index = self._index
4756        self._match(TokenType.PLUS)
4757
4758        # Convert INTERVAL 'val_1' unit_1 [+] ... [+] 'val_n' unit_n into a sum of intervals
4759        if self._match_set((TokenType.STRING, TokenType.NUMBER), advance=False):
4760            return self.expression(
4761                exp.Add, this=interval, expression=self._parse_interval(match_interval=False)
4762            )
4763
4764        self._retreat(index)
4765        return interval
4766
4767    def _parse_bitwise(self) -> t.Optional[exp.Expression]:
4768        this = self._parse_term()
4769
4770        while True:
4771            if self._match_set(self.BITWISE):
4772                this = self.expression(
4773                    self.BITWISE[self._prev.token_type],
4774                    this=this,
4775                    expression=self._parse_term(),
4776                )
4777            elif self.dialect.DPIPE_IS_STRING_CONCAT and self._match(TokenType.DPIPE):
4778                this = self.expression(
4779                    exp.DPipe,
4780                    this=this,
4781                    expression=self._parse_term(),
4782                    safe=not self.dialect.STRICT_STRING_CONCAT,
4783                )
4784            elif self._match(TokenType.DQMARK):
4785                this = self.expression(
4786                    exp.Coalesce, this=this, expressions=ensure_list(self._parse_term())
4787                )
4788            elif self._match_pair(TokenType.LT, TokenType.LT):
4789                this = self.expression(
4790                    exp.BitwiseLeftShift, this=this, expression=self._parse_term()
4791                )
4792            elif self._match_pair(TokenType.GT, TokenType.GT):
4793                this = self.expression(
4794                    exp.BitwiseRightShift, this=this, expression=self._parse_term()
4795                )
4796            else:
4797                break
4798
4799        return this
4800
4801    def _parse_term(self) -> t.Optional[exp.Expression]:
4802        this = self._parse_factor()
4803
4804        while self._match_set(self.TERM):
4805            klass = self.TERM[self._prev.token_type]
4806            comments = self._prev_comments
4807            expression = self._parse_factor()
4808
4809            this = self.expression(klass, this=this, comments=comments, expression=expression)
4810
4811            if isinstance(this, exp.Collate):
4812                expr = this.expression
4813
4814                # Preserve collations such as pg_catalog."default" (Postgres) as columns, otherwise
4815                # fallback to Identifier / Var
4816                if isinstance(expr, exp.Column) and len(expr.parts) == 1:
4817                    ident = expr.this
4818                    if isinstance(ident, exp.Identifier):
4819                        this.set("expression", ident if ident.quoted else exp.var(ident.name))
4820
4821        return this
4822
4823    def _parse_factor(self) -> t.Optional[exp.Expression]:
4824        parse_method = self._parse_exponent if self.EXPONENT else self._parse_unary
4825        this = parse_method()
4826
4827        while self._match_set(self.FACTOR):
4828            klass = self.FACTOR[self._prev.token_type]
4829            comments = self._prev_comments
4830            expression = parse_method()
4831
4832            if not expression and klass is exp.IntDiv and self._prev.text.isalpha():
4833                self._retreat(self._index - 1)
4834                return this
4835
4836            this = self.expression(klass, this=this, comments=comments, expression=expression)
4837
4838            if isinstance(this, exp.Div):
4839                this.args["typed"] = self.dialect.TYPED_DIVISION
4840                this.args["safe"] = self.dialect.SAFE_DIVISION
4841
4842        return this
4843
4844    def _parse_exponent(self) -> t.Optional[exp.Expression]:
4845        return self._parse_tokens(self._parse_unary, self.EXPONENT)
4846
4847    def _parse_unary(self) -> t.Optional[exp.Expression]:
4848        if self._match_set(self.UNARY_PARSERS):
4849            return self.UNARY_PARSERS[self._prev.token_type](self)
4850        return self._parse_at_time_zone(self._parse_type())
4851
4852    def _parse_type(
4853        self, parse_interval: bool = True, fallback_to_identifier: bool = False
4854    ) -> t.Optional[exp.Expression]:
4855        interval = parse_interval and self._parse_interval()
4856        if interval:
4857            return interval
4858
4859        index = self._index
4860        data_type = self._parse_types(check_func=True, allow_identifiers=False)
4861
4862        # parse_types() returns a Cast if we parsed BQ's inline constructor <type>(<values>) e.g.
4863        # STRUCT<a INT, b STRING>(1, 'foo'), which is canonicalized to CAST(<values> AS <type>)
4864        if isinstance(data_type, exp.Cast):
4865            # This constructor can contain ops directly after it, for instance struct unnesting:
4866            # STRUCT<a INT, b STRING>(1, 'foo').* --> CAST(STRUCT(1, 'foo') AS STRUCT<a iNT, b STRING).*
4867            return self._parse_column_ops(data_type)
4868
4869        if data_type:
4870            index2 = self._index
4871            this = self._parse_primary()
4872
4873            if isinstance(this, exp.Literal):
4874                parser = self.TYPE_LITERAL_PARSERS.get(data_type.this)
4875                if parser:
4876                    return parser(self, this, data_type)
4877
4878                return self.expression(exp.Cast, this=this, to=data_type)
4879
4880            # The expressions arg gets set by the parser when we have something like DECIMAL(38, 0)
4881            # in the input SQL. In that case, we'll produce these tokens: DECIMAL ( 38 , 0 )
4882            #
4883            # If the index difference here is greater than 1, that means the parser itself must have
4884            # consumed additional tokens such as the DECIMAL scale and precision in the above example.
4885            #
4886            # If it's not greater than 1, then it must be 1, because we've consumed at least the type
4887            # keyword, meaning that the expressions arg of the DataType must have gotten set by a
4888            # callable in the TYPE_CONVERTERS mapping. For example, Snowflake converts DECIMAL to
4889            # DECIMAL(38, 0)) in order to facilitate the data type's transpilation.
4890            #
4891            # In these cases, we don't really want to return the converted type, but instead retreat
4892            # and try to parse a Column or Identifier in the section below.
4893            if data_type.expressions and index2 - index > 1:
4894                self._retreat(index2)
4895                return self._parse_column_ops(data_type)
4896
4897            self._retreat(index)
4898
4899        if fallback_to_identifier:
4900            return self._parse_id_var()
4901
4902        this = self._parse_column()
4903        return this and self._parse_column_ops(this)
4904
4905    def _parse_type_size(self) -> t.Optional[exp.DataTypeParam]:
4906        this = self._parse_type()
4907        if not this:
4908            return None
4909
4910        if isinstance(this, exp.Column) and not this.table:
4911            this = exp.var(this.name.upper())
4912
4913        return self.expression(
4914            exp.DataTypeParam, this=this, expression=self._parse_var(any_token=True)
4915        )
4916
4917    def _parse_types(
4918        self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
4919    ) -> t.Optional[exp.Expression]:
4920        index = self._index
4921
4922        this: t.Optional[exp.Expression] = None
4923        prefix = self._match_text_seq("SYSUDTLIB", ".")
4924
4925        if not self._match_set(self.TYPE_TOKENS):
4926            identifier = allow_identifiers and self._parse_id_var(
4927                any_token=False, tokens=(TokenType.VAR,)
4928            )
4929            if isinstance(identifier, exp.Identifier):
4930                tokens = self.dialect.tokenize(identifier.sql(dialect=self.dialect))
4931
4932                if len(tokens) != 1:
4933                    self.raise_error("Unexpected identifier", self._prev)
4934
4935                if tokens[0].token_type in self.TYPE_TOKENS:
4936                    self._prev = tokens[0]
4937                elif self.dialect.SUPPORTS_USER_DEFINED_TYPES:
4938                    type_name = identifier.name
4939
4940                    while self._match(TokenType.DOT):
4941                        type_name = f"{type_name}.{self._advance_any() and self._prev.text}"
4942
4943                    this = exp.DataType.build(type_name, udt=True)
4944                else:
4945                    self._retreat(self._index - 1)
4946                    return None
4947            else:
4948                return None
4949
4950        type_token = self._prev.token_type
4951
4952        if type_token == TokenType.PSEUDO_TYPE:
4953            return self.expression(exp.PseudoType, this=self._prev.text.upper())
4954
4955        if type_token == TokenType.OBJECT_IDENTIFIER:
4956            return self.expression(exp.ObjectIdentifier, this=self._prev.text.upper())
4957
4958        # https://materialize.com/docs/sql/types/map/
4959        if type_token == TokenType.MAP and self._match(TokenType.L_BRACKET):
4960            key_type = self._parse_types(
4961                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
4962            )
4963            if not self._match(TokenType.FARROW):
4964                self._retreat(index)
4965                return None
4966
4967            value_type = self._parse_types(
4968                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
4969            )
4970            if not self._match(TokenType.R_BRACKET):
4971                self._retreat(index)
4972                return None
4973
4974            return exp.DataType(
4975                this=exp.DataType.Type.MAP,
4976                expressions=[key_type, value_type],
4977                nested=True,
4978                prefix=prefix,
4979            )
4980
4981        nested = type_token in self.NESTED_TYPE_TOKENS
4982        is_struct = type_token in self.STRUCT_TYPE_TOKENS
4983        is_aggregate = type_token in self.AGGREGATE_TYPE_TOKENS
4984        expressions = None
4985        maybe_func = False
4986
4987        if self._match(TokenType.L_PAREN):
4988            if is_struct:
4989                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
4990            elif nested:
4991                expressions = self._parse_csv(
4992                    lambda: self._parse_types(
4993                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
4994                    )
4995                )
4996                if type_token == TokenType.NULLABLE and len(expressions) == 1:
4997                    this = expressions[0]
4998                    this.set("nullable", True)
4999                    self._match_r_paren()
5000                    return this
5001            elif type_token in self.ENUM_TYPE_TOKENS:
5002                expressions = self._parse_csv(self._parse_equality)
5003            elif is_aggregate:
5004                func_or_ident = self._parse_function(anonymous=True) or self._parse_id_var(
5005                    any_token=False, tokens=(TokenType.VAR,)
5006                )
5007                if not func_or_ident or not self._match(TokenType.COMMA):
5008                    return None
5009                expressions = self._parse_csv(
5010                    lambda: self._parse_types(
5011                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5012                    )
5013                )
5014                expressions.insert(0, func_or_ident)
5015            else:
5016                expressions = self._parse_csv(self._parse_type_size)
5017
5018                # https://docs.snowflake.com/en/sql-reference/data-types-vector
5019                if type_token == TokenType.VECTOR and len(expressions) == 2:
5020                    expressions[0] = exp.DataType.build(expressions[0].name, dialect=self.dialect)
5021
5022            if not expressions or not self._match(TokenType.R_PAREN):
5023                self._retreat(index)
5024                return None
5025
5026            maybe_func = True
5027
5028        values: t.Optional[t.List[exp.Expression]] = None
5029
5030        if nested and self._match(TokenType.LT):
5031            if is_struct:
5032                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
5033            else:
5034                expressions = self._parse_csv(
5035                    lambda: self._parse_types(
5036                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5037                    )
5038                )
5039
5040            if not self._match(TokenType.GT):
5041                self.raise_error("Expecting >")
5042
5043            if self._match_set((TokenType.L_BRACKET, TokenType.L_PAREN)):
5044                values = self._parse_csv(self._parse_assignment)
5045                if not values and is_struct:
5046                    values = None
5047                    self._retreat(self._index - 1)
5048                else:
5049                    self._match_set((TokenType.R_BRACKET, TokenType.R_PAREN))
5050
5051        if type_token in self.TIMESTAMPS:
5052            if self._match_text_seq("WITH", "TIME", "ZONE"):
5053                maybe_func = False
5054                tz_type = (
5055                    exp.DataType.Type.TIMETZ
5056                    if type_token in self.TIMES
5057                    else exp.DataType.Type.TIMESTAMPTZ
5058                )
5059                this = exp.DataType(this=tz_type, expressions=expressions)
5060            elif self._match_text_seq("WITH", "LOCAL", "TIME", "ZONE"):
5061                maybe_func = False
5062                this = exp.DataType(this=exp.DataType.Type.TIMESTAMPLTZ, expressions=expressions)
5063            elif self._match_text_seq("WITHOUT", "TIME", "ZONE"):
5064                maybe_func = False
5065        elif type_token == TokenType.INTERVAL:
5066            unit = self._parse_var(upper=True)
5067            if unit:
5068                if self._match_text_seq("TO"):
5069                    unit = exp.IntervalSpan(this=unit, expression=self._parse_var(upper=True))
5070
5071                this = self.expression(exp.DataType, this=self.expression(exp.Interval, unit=unit))
5072            else:
5073                this = self.expression(exp.DataType, this=exp.DataType.Type.INTERVAL)
5074
5075        if maybe_func and check_func:
5076            index2 = self._index
5077            peek = self._parse_string()
5078
5079            if not peek:
5080                self._retreat(index)
5081                return None
5082
5083            self._retreat(index2)
5084
5085        if not this:
5086            if self._match_text_seq("UNSIGNED"):
5087                unsigned_type_token = self.SIGNED_TO_UNSIGNED_TYPE_TOKEN.get(type_token)
5088                if not unsigned_type_token:
5089                    self.raise_error(f"Cannot convert {type_token.value} to unsigned.")
5090
5091                type_token = unsigned_type_token or type_token
5092
5093            this = exp.DataType(
5094                this=exp.DataType.Type[type_token.value],
5095                expressions=expressions,
5096                nested=nested,
5097                prefix=prefix,
5098            )
5099
5100            # Empty arrays/structs are allowed
5101            if values is not None:
5102                cls = exp.Struct if is_struct else exp.Array
5103                this = exp.cast(cls(expressions=values), this, copy=False)
5104
5105        elif expressions:
5106            this.set("expressions", expressions)
5107
5108        # https://materialize.com/docs/sql/types/list/#type-name
5109        while self._match(TokenType.LIST):
5110            this = exp.DataType(this=exp.DataType.Type.LIST, expressions=[this], nested=True)
5111
5112        index = self._index
5113
5114        # Postgres supports the INT ARRAY[3] syntax as a synonym for INT[3]
5115        matched_array = self._match(TokenType.ARRAY)
5116
5117        while self._curr:
5118            datatype_token = self._prev.token_type
5119            matched_l_bracket = self._match(TokenType.L_BRACKET)
5120
5121            if (not matched_l_bracket and not matched_array) or (
5122                datatype_token == TokenType.ARRAY and self._match(TokenType.R_BRACKET)
5123            ):
5124                # Postgres allows casting empty arrays such as ARRAY[]::INT[],
5125                # not to be confused with the fixed size array parsing
5126                break
5127
5128            matched_array = False
5129            values = self._parse_csv(self._parse_assignment) or None
5130            if (
5131                values
5132                and not schema
5133                and (
5134                    not self.dialect.SUPPORTS_FIXED_SIZE_ARRAYS or datatype_token == TokenType.ARRAY
5135                )
5136            ):
5137                # Retreating here means that we should not parse the following values as part of the data type, e.g. in DuckDB
5138                # ARRAY[1] should retreat and instead be parsed into exp.Array in contrast to INT[x][y] which denotes a fixed-size array data type
5139                self._retreat(index)
5140                break
5141
5142            this = exp.DataType(
5143                this=exp.DataType.Type.ARRAY, expressions=[this], values=values, nested=True
5144            )
5145            self._match(TokenType.R_BRACKET)
5146
5147        if self.TYPE_CONVERTERS and isinstance(this.this, exp.DataType.Type):
5148            converter = self.TYPE_CONVERTERS.get(this.this)
5149            if converter:
5150                this = converter(t.cast(exp.DataType, this))
5151
5152        return this
5153
5154    def _parse_struct_types(self, type_required: bool = False) -> t.Optional[exp.Expression]:
5155        index = self._index
5156
5157        if (
5158            self._curr
5159            and self._next
5160            and self._curr.token_type in self.TYPE_TOKENS
5161            and self._next.token_type in self.TYPE_TOKENS
5162        ):
5163            # Takes care of special cases like `STRUCT<list ARRAY<...>>` where the identifier is also a
5164            # type token. Without this, the list will be parsed as a type and we'll eventually crash
5165            this = self._parse_id_var()
5166        else:
5167            this = (
5168                self._parse_type(parse_interval=False, fallback_to_identifier=True)
5169                or self._parse_id_var()
5170            )
5171
5172        self._match(TokenType.COLON)
5173
5174        if (
5175            type_required
5176            and not isinstance(this, exp.DataType)
5177            and not self._match_set(self.TYPE_TOKENS, advance=False)
5178        ):
5179            self._retreat(index)
5180            return self._parse_types()
5181
5182        return self._parse_column_def(this)
5183
5184    def _parse_at_time_zone(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5185        if not self._match_text_seq("AT", "TIME", "ZONE"):
5186            return this
5187        return self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
5188
5189    def _parse_column(self) -> t.Optional[exp.Expression]:
5190        this = self._parse_column_reference()
5191        column = self._parse_column_ops(this) if this else self._parse_bracket(this)
5192
5193        if self.dialect.SUPPORTS_COLUMN_JOIN_MARKS and column:
5194            column.set("join_mark", self._match(TokenType.JOIN_MARKER))
5195
5196        return column
5197
5198    def _parse_column_reference(self) -> t.Optional[exp.Expression]:
5199        this = self._parse_field()
5200        if (
5201            not this
5202            and self._match(TokenType.VALUES, advance=False)
5203            and self.VALUES_FOLLOWED_BY_PAREN
5204            and (not self._next or self._next.token_type != TokenType.L_PAREN)
5205        ):
5206            this = self._parse_id_var()
5207
5208        if isinstance(this, exp.Identifier):
5209            # We bubble up comments from the Identifier to the Column
5210            this = self.expression(exp.Column, comments=this.pop_comments(), this=this)
5211
5212        return this
5213
5214    def _parse_colon_as_variant_extract(
5215        self, this: t.Optional[exp.Expression]
5216    ) -> t.Optional[exp.Expression]:
5217        casts = []
5218        json_path = []
5219        escape = None
5220
5221        while self._match(TokenType.COLON):
5222            start_index = self._index
5223
5224            # Snowflake allows reserved keywords as json keys but advance_any() excludes TokenType.SELECT from any_tokens=True
5225            path = self._parse_column_ops(
5226                self._parse_field(any_token=True, tokens=(TokenType.SELECT,))
5227            )
5228
5229            # The cast :: operator has a lower precedence than the extraction operator :, so
5230            # we rearrange the AST appropriately to avoid casting the JSON path
5231            while isinstance(path, exp.Cast):
5232                casts.append(path.to)
5233                path = path.this
5234
5235            if casts:
5236                dcolon_offset = next(
5237                    i
5238                    for i, t in enumerate(self._tokens[start_index:])
5239                    if t.token_type == TokenType.DCOLON
5240                )
5241                end_token = self._tokens[start_index + dcolon_offset - 1]
5242            else:
5243                end_token = self._prev
5244
5245            if path:
5246                # Escape single quotes from Snowflake's colon extraction (e.g. col:"a'b") as
5247                # it'll roundtrip to a string literal in GET_PATH
5248                if isinstance(path, exp.Identifier) and path.quoted:
5249                    escape = True
5250
5251                json_path.append(self._find_sql(self._tokens[start_index], end_token))
5252
5253        # The VARIANT extract in Snowflake/Databricks is parsed as a JSONExtract; Snowflake uses the json_path in GET_PATH() while
5254        # Databricks transforms it back to the colon/dot notation
5255        if json_path:
5256            json_path_expr = self.dialect.to_json_path(exp.Literal.string(".".join(json_path)))
5257
5258            if json_path_expr:
5259                json_path_expr.set("escape", escape)
5260
5261            this = self.expression(
5262                exp.JSONExtract,
5263                this=this,
5264                expression=json_path_expr,
5265                variant_extract=True,
5266            )
5267
5268            while casts:
5269                this = self.expression(exp.Cast, this=this, to=casts.pop())
5270
5271        return this
5272
5273    def _parse_dcolon(self) -> t.Optional[exp.Expression]:
5274        return self._parse_types()
5275
5276    def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5277        this = self._parse_bracket(this)
5278
5279        while self._match_set(self.COLUMN_OPERATORS):
5280            op_token = self._prev.token_type
5281            op = self.COLUMN_OPERATORS.get(op_token)
5282
5283            if op_token == TokenType.DCOLON:
5284                field = self._parse_dcolon()
5285                if not field:
5286                    self.raise_error("Expected type")
5287            elif op and self._curr:
5288                field = self._parse_column_reference() or self._parse_bracket()
5289            else:
5290                field = self._parse_field(any_token=True, anonymous_func=True)
5291
5292            if isinstance(field, (exp.Func, exp.Window)) and this:
5293                # BQ & snowflake allow function calls like x.y.count(...), SAFE.SUBSTR(...) etc
5294                # https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-reference#function_call_rules
5295                this = exp.replace_tree(
5296                    this,
5297                    lambda n: (
5298                        self.expression(exp.Dot, this=n.args.get("table"), expression=n.this)
5299                        if n.table
5300                        else n.this
5301                    )
5302                    if isinstance(n, exp.Column)
5303                    else n,
5304                )
5305
5306            if op:
5307                this = op(self, this, field)
5308            elif isinstance(this, exp.Column) and not this.args.get("catalog"):
5309                this = self.expression(
5310                    exp.Column,
5311                    comments=this.comments,
5312                    this=field,
5313                    table=this.this,
5314                    db=this.args.get("table"),
5315                    catalog=this.args.get("db"),
5316                )
5317            elif isinstance(field, exp.Window):
5318                # Move the exp.Dot's to the window's function
5319                window_func = self.expression(exp.Dot, this=this, expression=field.this)
5320                field.set("this", window_func)
5321                this = field
5322            else:
5323                this = self.expression(exp.Dot, this=this, expression=field)
5324
5325            if field and field.comments:
5326                t.cast(exp.Expression, this).add_comments(field.pop_comments())
5327
5328            this = self._parse_bracket(this)
5329
5330        return self._parse_colon_as_variant_extract(this) if self.COLON_IS_VARIANT_EXTRACT else this
5331
5332    def _parse_primary(self) -> t.Optional[exp.Expression]:
5333        if self._match_set(self.PRIMARY_PARSERS):
5334            token_type = self._prev.token_type
5335            primary = self.PRIMARY_PARSERS[token_type](self, self._prev)
5336
5337            if token_type == TokenType.STRING:
5338                expressions = [primary]
5339                while self._match(TokenType.STRING):
5340                    expressions.append(exp.Literal.string(self._prev.text))
5341
5342                if len(expressions) > 1:
5343                    return self.expression(exp.Concat, expressions=expressions)
5344
5345            return primary
5346
5347        if self._match_pair(TokenType.DOT, TokenType.NUMBER):
5348            return exp.Literal.number(f"0.{self._prev.text}")
5349
5350        if self._match(TokenType.L_PAREN):
5351            comments = self._prev_comments
5352            query = self._parse_select()
5353
5354            if query:
5355                expressions = [query]
5356            else:
5357                expressions = self._parse_expressions()
5358
5359            this = self._parse_query_modifiers(seq_get(expressions, 0))
5360
5361            if not this and self._match(TokenType.R_PAREN, advance=False):
5362                this = self.expression(exp.Tuple)
5363            elif isinstance(this, exp.UNWRAPPED_QUERIES):
5364                this = self._parse_subquery(this=this, parse_alias=False)
5365            elif isinstance(this, exp.Subquery):
5366                this = self._parse_subquery(
5367                    this=self._parse_set_operations(this), parse_alias=False
5368                )
5369            elif len(expressions) > 1 or self._prev.token_type == TokenType.COMMA:
5370                this = self.expression(exp.Tuple, expressions=expressions)
5371            else:
5372                this = self.expression(exp.Paren, this=this)
5373
5374            if this:
5375                this.add_comments(comments)
5376
5377            self._match_r_paren(expression=this)
5378            return this
5379
5380        return None
5381
5382    def _parse_field(
5383        self,
5384        any_token: bool = False,
5385        tokens: t.Optional[t.Collection[TokenType]] = None,
5386        anonymous_func: bool = False,
5387    ) -> t.Optional[exp.Expression]:
5388        if anonymous_func:
5389            field = (
5390                self._parse_function(anonymous=anonymous_func, any_token=any_token)
5391                or self._parse_primary()
5392            )
5393        else:
5394            field = self._parse_primary() or self._parse_function(
5395                anonymous=anonymous_func, any_token=any_token
5396            )
5397        return field or self._parse_id_var(any_token=any_token, tokens=tokens)
5398
5399    def _parse_function(
5400        self,
5401        functions: t.Optional[t.Dict[str, t.Callable]] = None,
5402        anonymous: bool = False,
5403        optional_parens: bool = True,
5404        any_token: bool = False,
5405    ) -> t.Optional[exp.Expression]:
5406        # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this)
5407        # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences
5408        fn_syntax = False
5409        if (
5410            self._match(TokenType.L_BRACE, advance=False)
5411            and self._next
5412            and self._next.text.upper() == "FN"
5413        ):
5414            self._advance(2)
5415            fn_syntax = True
5416
5417        func = self._parse_function_call(
5418            functions=functions,
5419            anonymous=anonymous,
5420            optional_parens=optional_parens,
5421            any_token=any_token,
5422        )
5423
5424        if fn_syntax:
5425            self._match(TokenType.R_BRACE)
5426
5427        return func
5428
5429    def _parse_function_call(
5430        self,
5431        functions: t.Optional[t.Dict[str, t.Callable]] = None,
5432        anonymous: bool = False,
5433        optional_parens: bool = True,
5434        any_token: bool = False,
5435    ) -> t.Optional[exp.Expression]:
5436        if not self._curr:
5437            return None
5438
5439        comments = self._curr.comments
5440        token_type = self._curr.token_type
5441        this = self._curr.text
5442        upper = this.upper()
5443
5444        parser = self.NO_PAREN_FUNCTION_PARSERS.get(upper)
5445        if optional_parens and parser and token_type not in self.INVALID_FUNC_NAME_TOKENS:
5446            self._advance()
5447            return self._parse_window(parser(self))
5448
5449        if not self._next or self._next.token_type != TokenType.L_PAREN:
5450            if optional_parens and token_type in self.NO_PAREN_FUNCTIONS:
5451                self._advance()
5452                return self.expression(self.NO_PAREN_FUNCTIONS[token_type])
5453
5454            return None
5455
5456        if any_token:
5457            if token_type in self.RESERVED_TOKENS:
5458                return None
5459        elif token_type not in self.FUNC_TOKENS:
5460            return None
5461
5462        self._advance(2)
5463
5464        parser = self.FUNCTION_PARSERS.get(upper)
5465        if parser and not anonymous:
5466            this = parser(self)
5467        else:
5468            subquery_predicate = self.SUBQUERY_PREDICATES.get(token_type)
5469
5470            if subquery_predicate and self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
5471                this = self.expression(
5472                    subquery_predicate, comments=comments, this=self._parse_select()
5473                )
5474                self._match_r_paren()
5475                return this
5476
5477            if functions is None:
5478                functions = self.FUNCTIONS
5479
5480            function = functions.get(upper)
5481            known_function = function and not anonymous
5482
5483            alias = not known_function or upper in self.FUNCTIONS_WITH_ALIASED_ARGS
5484            args = self._parse_csv(lambda: self._parse_lambda(alias=alias))
5485
5486            post_func_comments = self._curr and self._curr.comments
5487            if known_function and post_func_comments:
5488                # If the user-inputted comment "/* sqlglot.anonymous */" is following the function
5489                # call we'll construct it as exp.Anonymous, even if it's "known"
5490                if any(
5491                    comment.lstrip().startswith(exp.SQLGLOT_ANONYMOUS)
5492                    for comment in post_func_comments
5493                ):
5494                    known_function = False
5495
5496            if alias and known_function:
5497                args = self._kv_to_prop_eq(args)
5498
5499            if known_function:
5500                func_builder = t.cast(t.Callable, function)
5501
5502                if "dialect" in func_builder.__code__.co_varnames:
5503                    func = func_builder(args, dialect=self.dialect)
5504                else:
5505                    func = func_builder(args)
5506
5507                func = self.validate_expression(func, args)
5508                if self.dialect.PRESERVE_ORIGINAL_NAMES:
5509                    func.meta["name"] = this
5510
5511                this = func
5512            else:
5513                if token_type == TokenType.IDENTIFIER:
5514                    this = exp.Identifier(this=this, quoted=True)
5515                this = self.expression(exp.Anonymous, this=this, expressions=args)
5516
5517        if isinstance(this, exp.Expression):
5518            this.add_comments(comments)
5519
5520        self._match_r_paren(this)
5521        return self._parse_window(this)
5522
5523    def _to_prop_eq(self, expression: exp.Expression, index: int) -> exp.Expression:
5524        return expression
5525
5526    def _kv_to_prop_eq(self, expressions: t.List[exp.Expression]) -> t.List[exp.Expression]:
5527        transformed = []
5528
5529        for index, e in enumerate(expressions):
5530            if isinstance(e, self.KEY_VALUE_DEFINITIONS):
5531                if isinstance(e, exp.Alias):
5532                    e = self.expression(exp.PropertyEQ, this=e.args.get("alias"), expression=e.this)
5533
5534                if not isinstance(e, exp.PropertyEQ):
5535                    e = self.expression(
5536                        exp.PropertyEQ, this=exp.to_identifier(e.this.name), expression=e.expression
5537                    )
5538
5539                if isinstance(e.this, exp.Column):
5540                    e.this.replace(e.this.this)
5541            else:
5542                e = self._to_prop_eq(e, index)
5543
5544            transformed.append(e)
5545
5546        return transformed
5547
5548    def _parse_user_defined_function_expression(self) -> t.Optional[exp.Expression]:
5549        return self._parse_statement()
5550
5551    def _parse_function_parameter(self) -> t.Optional[exp.Expression]:
5552        return self._parse_column_def(self._parse_id_var())
5553
5554    def _parse_user_defined_function(
5555        self, kind: t.Optional[TokenType] = None
5556    ) -> t.Optional[exp.Expression]:
5557        this = self._parse_id_var()
5558
5559        while self._match(TokenType.DOT):
5560            this = self.expression(exp.Dot, this=this, expression=self._parse_id_var())
5561
5562        if not self._match(TokenType.L_PAREN):
5563            return this
5564
5565        expressions = self._parse_csv(self._parse_function_parameter)
5566        self._match_r_paren()
5567        return self.expression(
5568            exp.UserDefinedFunction, this=this, expressions=expressions, wrapped=True
5569        )
5570
5571    def _parse_introducer(self, token: Token) -> exp.Introducer | exp.Identifier:
5572        literal = self._parse_primary()
5573        if literal:
5574            return self.expression(exp.Introducer, this=token.text, expression=literal)
5575
5576        return self.expression(exp.Identifier, this=token.text)
5577
5578    def _parse_session_parameter(self) -> exp.SessionParameter:
5579        kind = None
5580        this = self._parse_id_var() or self._parse_primary()
5581
5582        if this and self._match(TokenType.DOT):
5583            kind = this.name
5584            this = self._parse_var() or self._parse_primary()
5585
5586        return self.expression(exp.SessionParameter, this=this, kind=kind)
5587
5588    def _parse_lambda_arg(self) -> t.Optional[exp.Expression]:
5589        return self._parse_id_var()
5590
5591    def _parse_lambda(self, alias: bool = False) -> t.Optional[exp.Expression]:
5592        index = self._index
5593
5594        if self._match(TokenType.L_PAREN):
5595            expressions = t.cast(
5596                t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_lambda_arg)
5597            )
5598
5599            if not self._match(TokenType.R_PAREN):
5600                self._retreat(index)
5601        else:
5602            expressions = [self._parse_lambda_arg()]
5603
5604        if self._match_set(self.LAMBDAS):
5605            return self.LAMBDAS[self._prev.token_type](self, expressions)
5606
5607        self._retreat(index)
5608
5609        this: t.Optional[exp.Expression]
5610
5611        if self._match(TokenType.DISTINCT):
5612            this = self.expression(
5613                exp.Distinct, expressions=self._parse_csv(self._parse_assignment)
5614            )
5615        else:
5616            this = self._parse_select_or_expression(alias=alias)
5617
5618        return self._parse_limit(
5619            self._parse_order(self._parse_having_max(self._parse_respect_or_ignore_nulls(this)))
5620        )
5621
5622    def _parse_schema(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
5623        index = self._index
5624        if not self._match(TokenType.L_PAREN):
5625            return this
5626
5627        # Disambiguate between schema and subquery/CTE, e.g. in INSERT INTO table (<expr>),
5628        # expr can be of both types
5629        if self._match_set(self.SELECT_START_TOKENS):
5630            self._retreat(index)
5631            return this
5632        args = self._parse_csv(lambda: self._parse_constraint() or self._parse_field_def())
5633        self._match_r_paren()
5634        return self.expression(exp.Schema, this=this, expressions=args)
5635
5636    def _parse_field_def(self) -> t.Optional[exp.Expression]:
5637        return self._parse_column_def(self._parse_field(any_token=True))
5638
5639    def _parse_column_def(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5640        # column defs are not really columns, they're identifiers
5641        if isinstance(this, exp.Column):
5642            this = this.this
5643
5644        kind = self._parse_types(schema=True)
5645
5646        if self._match_text_seq("FOR", "ORDINALITY"):
5647            return self.expression(exp.ColumnDef, this=this, ordinality=True)
5648
5649        constraints: t.List[exp.Expression] = []
5650
5651        if (not kind and self._match(TokenType.ALIAS)) or self._match_texts(
5652            ("ALIAS", "MATERIALIZED")
5653        ):
5654            persisted = self._prev.text.upper() == "MATERIALIZED"
5655            constraint_kind = exp.ComputedColumnConstraint(
5656                this=self._parse_assignment(),
5657                persisted=persisted or self._match_text_seq("PERSISTED"),
5658                not_null=self._match_pair(TokenType.NOT, TokenType.NULL),
5659            )
5660            constraints.append(self.expression(exp.ColumnConstraint, kind=constraint_kind))
5661        elif (
5662            kind
5663            and self._match(TokenType.ALIAS, advance=False)
5664            and (
5665                not self.WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
5666                or (self._next and self._next.token_type == TokenType.L_PAREN)
5667            )
5668        ):
5669            self._advance()
5670            constraints.append(
5671                self.expression(
5672                    exp.ColumnConstraint,
5673                    kind=exp.TransformColumnConstraint(this=self._parse_disjunction()),
5674                )
5675            )
5676
5677        while True:
5678            constraint = self._parse_column_constraint()
5679            if not constraint:
5680                break
5681            constraints.append(constraint)
5682
5683        if not kind and not constraints:
5684            return this
5685
5686        return self.expression(exp.ColumnDef, this=this, kind=kind, constraints=constraints)
5687
5688    def _parse_auto_increment(
5689        self,
5690    ) -> exp.GeneratedAsIdentityColumnConstraint | exp.AutoIncrementColumnConstraint:
5691        start = None
5692        increment = None
5693
5694        if self._match(TokenType.L_PAREN, advance=False):
5695            args = self._parse_wrapped_csv(self._parse_bitwise)
5696            start = seq_get(args, 0)
5697            increment = seq_get(args, 1)
5698        elif self._match_text_seq("START"):
5699            start = self._parse_bitwise()
5700            self._match_text_seq("INCREMENT")
5701            increment = self._parse_bitwise()
5702
5703        if start and increment:
5704            return exp.GeneratedAsIdentityColumnConstraint(start=start, increment=increment)
5705
5706        return exp.AutoIncrementColumnConstraint()
5707
5708    def _parse_auto_property(self) -> t.Optional[exp.AutoRefreshProperty]:
5709        if not self._match_text_seq("REFRESH"):
5710            self._retreat(self._index - 1)
5711            return None
5712        return self.expression(exp.AutoRefreshProperty, this=self._parse_var(upper=True))
5713
5714    def _parse_compress(self) -> exp.CompressColumnConstraint:
5715        if self._match(TokenType.L_PAREN, advance=False):
5716            return self.expression(
5717                exp.CompressColumnConstraint, this=self._parse_wrapped_csv(self._parse_bitwise)
5718            )
5719
5720        return self.expression(exp.CompressColumnConstraint, this=self._parse_bitwise())
5721
5722    def _parse_generated_as_identity(
5723        self,
5724    ) -> (
5725        exp.GeneratedAsIdentityColumnConstraint
5726        | exp.ComputedColumnConstraint
5727        | exp.GeneratedAsRowColumnConstraint
5728    ):
5729        if self._match_text_seq("BY", "DEFAULT"):
5730            on_null = self._match_pair(TokenType.ON, TokenType.NULL)
5731            this = self.expression(
5732                exp.GeneratedAsIdentityColumnConstraint, this=False, on_null=on_null
5733            )
5734        else:
5735            self._match_text_seq("ALWAYS")
5736            this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True)
5737
5738        self._match(TokenType.ALIAS)
5739
5740        if self._match_text_seq("ROW"):
5741            start = self._match_text_seq("START")
5742            if not start:
5743                self._match(TokenType.END)
5744            hidden = self._match_text_seq("HIDDEN")
5745            return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden)
5746
5747        identity = self._match_text_seq("IDENTITY")
5748
5749        if self._match(TokenType.L_PAREN):
5750            if self._match(TokenType.START_WITH):
5751                this.set("start", self._parse_bitwise())
5752            if self._match_text_seq("INCREMENT", "BY"):
5753                this.set("increment", self._parse_bitwise())
5754            if self._match_text_seq("MINVALUE"):
5755                this.set("minvalue", self._parse_bitwise())
5756            if self._match_text_seq("MAXVALUE"):
5757                this.set("maxvalue", self._parse_bitwise())
5758
5759            if self._match_text_seq("CYCLE"):
5760                this.set("cycle", True)
5761            elif self._match_text_seq("NO", "CYCLE"):
5762                this.set("cycle", False)
5763
5764            if not identity:
5765                this.set("expression", self._parse_range())
5766            elif not this.args.get("start") and self._match(TokenType.NUMBER, advance=False):
5767                args = self._parse_csv(self._parse_bitwise)
5768                this.set("start", seq_get(args, 0))
5769                this.set("increment", seq_get(args, 1))
5770
5771            self._match_r_paren()
5772
5773        return this
5774
5775    def _parse_inline(self) -> exp.InlineLengthColumnConstraint:
5776        self._match_text_seq("LENGTH")
5777        return self.expression(exp.InlineLengthColumnConstraint, this=self._parse_bitwise())
5778
5779    def _parse_not_constraint(self) -> t.Optional[exp.Expression]:
5780        if self._match_text_seq("NULL"):
5781            return self.expression(exp.NotNullColumnConstraint)
5782        if self._match_text_seq("CASESPECIFIC"):
5783            return self.expression(exp.CaseSpecificColumnConstraint, not_=True)
5784        if self._match_text_seq("FOR", "REPLICATION"):
5785            return self.expression(exp.NotForReplicationColumnConstraint)
5786
5787        # Unconsume the `NOT` token
5788        self._retreat(self._index - 1)
5789        return None
5790
5791    def _parse_column_constraint(self) -> t.Optional[exp.Expression]:
5792        this = self._match(TokenType.CONSTRAINT) and self._parse_id_var()
5793
5794        procedure_option_follows = (
5795            self._match(TokenType.WITH, advance=False)
5796            and self._next
5797            and self._next.text.upper() in self.PROCEDURE_OPTIONS
5798        )
5799
5800        if not procedure_option_follows and self._match_texts(self.CONSTRAINT_PARSERS):
5801            return self.expression(
5802                exp.ColumnConstraint,
5803                this=this,
5804                kind=self.CONSTRAINT_PARSERS[self._prev.text.upper()](self),
5805            )
5806
5807        return this
5808
5809    def _parse_constraint(self) -> t.Optional[exp.Expression]:
5810        if not self._match(TokenType.CONSTRAINT):
5811            return self._parse_unnamed_constraint(constraints=self.SCHEMA_UNNAMED_CONSTRAINTS)
5812
5813        return self.expression(
5814            exp.Constraint,
5815            this=self._parse_id_var(),
5816            expressions=self._parse_unnamed_constraints(),
5817        )
5818
5819    def _parse_unnamed_constraints(self) -> t.List[exp.Expression]:
5820        constraints = []
5821        while True:
5822            constraint = self._parse_unnamed_constraint() or self._parse_function()
5823            if not constraint:
5824                break
5825            constraints.append(constraint)
5826
5827        return constraints
5828
5829    def _parse_unnamed_constraint(
5830        self, constraints: t.Optional[t.Collection[str]] = None
5831    ) -> t.Optional[exp.Expression]:
5832        if self._match(TokenType.IDENTIFIER, advance=False) or not self._match_texts(
5833            constraints or self.CONSTRAINT_PARSERS
5834        ):
5835            return None
5836
5837        constraint = self._prev.text.upper()
5838        if constraint not in self.CONSTRAINT_PARSERS:
5839            self.raise_error(f"No parser found for schema constraint {constraint}.")
5840
5841        return self.CONSTRAINT_PARSERS[constraint](self)
5842
5843    def _parse_unique_key(self) -> t.Optional[exp.Expression]:
5844        return self._parse_id_var(any_token=False)
5845
5846    def _parse_unique(self) -> exp.UniqueColumnConstraint:
5847        self._match_text_seq("KEY")
5848        return self.expression(
5849            exp.UniqueColumnConstraint,
5850            nulls=self._match_text_seq("NULLS", "NOT", "DISTINCT"),
5851            this=self._parse_schema(self._parse_unique_key()),
5852            index_type=self._match(TokenType.USING) and self._advance_any() and self._prev.text,
5853            on_conflict=self._parse_on_conflict(),
5854        )
5855
5856    def _parse_key_constraint_options(self) -> t.List[str]:
5857        options = []
5858        while True:
5859            if not self._curr:
5860                break
5861
5862            if self._match(TokenType.ON):
5863                action = None
5864                on = self._advance_any() and self._prev.text
5865
5866                if self._match_text_seq("NO", "ACTION"):
5867                    action = "NO ACTION"
5868                elif self._match_text_seq("CASCADE"):
5869                    action = "CASCADE"
5870                elif self._match_text_seq("RESTRICT"):
5871                    action = "RESTRICT"
5872                elif self._match_pair(TokenType.SET, TokenType.NULL):
5873                    action = "SET NULL"
5874                elif self._match_pair(TokenType.SET, TokenType.DEFAULT):
5875                    action = "SET DEFAULT"
5876                else:
5877                    self.raise_error("Invalid key constraint")
5878
5879                options.append(f"ON {on} {action}")
5880            else:
5881                var = self._parse_var_from_options(
5882                    self.KEY_CONSTRAINT_OPTIONS, raise_unmatched=False
5883                )
5884                if not var:
5885                    break
5886                options.append(var.name)
5887
5888        return options
5889
5890    def _parse_references(self, match: bool = True) -> t.Optional[exp.Reference]:
5891        if match and not self._match(TokenType.REFERENCES):
5892            return None
5893
5894        expressions = None
5895        this = self._parse_table(schema=True)
5896        options = self._parse_key_constraint_options()
5897        return self.expression(exp.Reference, this=this, expressions=expressions, options=options)
5898
5899    def _parse_foreign_key(self) -> exp.ForeignKey:
5900        expressions = self._parse_wrapped_id_vars()
5901        reference = self._parse_references()
5902        options = {}
5903
5904        while self._match(TokenType.ON):
5905            if not self._match_set((TokenType.DELETE, TokenType.UPDATE)):
5906                self.raise_error("Expected DELETE or UPDATE")
5907
5908            kind = self._prev.text.lower()
5909
5910            if self._match_text_seq("NO", "ACTION"):
5911                action = "NO ACTION"
5912            elif self._match(TokenType.SET):
5913                self._match_set((TokenType.NULL, TokenType.DEFAULT))
5914                action = "SET " + self._prev.text.upper()
5915            else:
5916                self._advance()
5917                action = self._prev.text.upper()
5918
5919            options[kind] = action
5920
5921        return self.expression(
5922            exp.ForeignKey,
5923            expressions=expressions,
5924            reference=reference,
5925            **options,  # type: ignore
5926        )
5927
5928    def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
5929        return self._parse_ordered() or self._parse_field()
5930
5931    def _parse_period_for_system_time(self) -> t.Optional[exp.PeriodForSystemTimeConstraint]:
5932        if not self._match(TokenType.TIMESTAMP_SNAPSHOT):
5933            self._retreat(self._index - 1)
5934            return None
5935
5936        id_vars = self._parse_wrapped_id_vars()
5937        return self.expression(
5938            exp.PeriodForSystemTimeConstraint,
5939            this=seq_get(id_vars, 0),
5940            expression=seq_get(id_vars, 1),
5941        )
5942
5943    def _parse_primary_key(
5944        self, wrapped_optional: bool = False, in_props: bool = False
5945    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
5946        desc = (
5947            self._match_set((TokenType.ASC, TokenType.DESC))
5948            and self._prev.token_type == TokenType.DESC
5949        )
5950
5951        if not in_props and not self._match(TokenType.L_PAREN, advance=False):
5952            return self.expression(exp.PrimaryKeyColumnConstraint, desc=desc)
5953
5954        expressions = self._parse_wrapped_csv(
5955            self._parse_primary_key_part, optional=wrapped_optional
5956        )
5957        options = self._parse_key_constraint_options()
5958        return self.expression(exp.PrimaryKey, expressions=expressions, options=options)
5959
5960    def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
5961        return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
5962
5963    def _parse_odbc_datetime_literal(self) -> exp.Expression:
5964        """
5965        Parses a datetime column in ODBC format. We parse the column into the corresponding
5966        types, for example `{d'yyyy-mm-dd'}` will be parsed as a `Date` column, exactly the
5967        same as we did for `DATE('yyyy-mm-dd')`.
5968
5969        Reference:
5970        https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/date-time-and-timestamp-literals
5971        """
5972        self._match(TokenType.VAR)
5973        exp_class = self.ODBC_DATETIME_LITERALS[self._prev.text.lower()]
5974        expression = self.expression(exp_class=exp_class, this=self._parse_string())
5975        if not self._match(TokenType.R_BRACE):
5976            self.raise_error("Expected }")
5977        return expression
5978
5979    def _parse_bracket(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
5980        if not self._match_set((TokenType.L_BRACKET, TokenType.L_BRACE)):
5981            return this
5982
5983        bracket_kind = self._prev.token_type
5984        if (
5985            bracket_kind == TokenType.L_BRACE
5986            and self._curr
5987            and self._curr.token_type == TokenType.VAR
5988            and self._curr.text.lower() in self.ODBC_DATETIME_LITERALS
5989        ):
5990            return self._parse_odbc_datetime_literal()
5991
5992        expressions = self._parse_csv(
5993            lambda: self._parse_bracket_key_value(is_map=bracket_kind == TokenType.L_BRACE)
5994        )
5995
5996        if bracket_kind == TokenType.L_BRACKET and not self._match(TokenType.R_BRACKET):
5997            self.raise_error("Expected ]")
5998        elif bracket_kind == TokenType.L_BRACE and not self._match(TokenType.R_BRACE):
5999            self.raise_error("Expected }")
6000
6001        # https://duckdb.org/docs/sql/data_types/struct.html#creating-structs
6002        if bracket_kind == TokenType.L_BRACE:
6003            this = self.expression(exp.Struct, expressions=self._kv_to_prop_eq(expressions))
6004        elif not this:
6005            this = build_array_constructor(
6006                exp.Array, args=expressions, bracket_kind=bracket_kind, dialect=self.dialect
6007            )
6008        else:
6009            constructor_type = self.ARRAY_CONSTRUCTORS.get(this.name.upper())
6010            if constructor_type:
6011                return build_array_constructor(
6012                    constructor_type,
6013                    args=expressions,
6014                    bracket_kind=bracket_kind,
6015                    dialect=self.dialect,
6016                )
6017
6018            expressions = apply_index_offset(this, expressions, -self.dialect.INDEX_OFFSET)
6019            this = self.expression(exp.Bracket, this=this, expressions=expressions)
6020
6021        self._add_comments(this)
6022        return self._parse_bracket(this)
6023
6024    def _parse_slice(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6025        if self._match(TokenType.COLON):
6026            return self.expression(exp.Slice, this=this, expression=self._parse_assignment())
6027        return this
6028
6029    def _parse_case(self) -> t.Optional[exp.Expression]:
6030        ifs = []
6031        default = None
6032
6033        comments = self._prev_comments
6034        expression = self._parse_assignment()
6035
6036        while self._match(TokenType.WHEN):
6037            this = self._parse_assignment()
6038            self._match(TokenType.THEN)
6039            then = self._parse_assignment()
6040            ifs.append(self.expression(exp.If, this=this, true=then))
6041
6042        if self._match(TokenType.ELSE):
6043            default = self._parse_assignment()
6044
6045        if not self._match(TokenType.END):
6046            if isinstance(default, exp.Interval) and default.this.sql().upper() == "END":
6047                default = exp.column("interval")
6048            else:
6049                self.raise_error("Expected END after CASE", self._prev)
6050
6051        return self.expression(
6052            exp.Case, comments=comments, this=expression, ifs=ifs, default=default
6053        )
6054
6055    def _parse_if(self) -> t.Optional[exp.Expression]:
6056        if self._match(TokenType.L_PAREN):
6057            args = self._parse_csv(self._parse_assignment)
6058            this = self.validate_expression(exp.If.from_arg_list(args), args)
6059            self._match_r_paren()
6060        else:
6061            index = self._index - 1
6062
6063            if self.NO_PAREN_IF_COMMANDS and index == 0:
6064                return self._parse_as_command(self._prev)
6065
6066            condition = self._parse_assignment()
6067
6068            if not condition:
6069                self._retreat(index)
6070                return None
6071
6072            self._match(TokenType.THEN)
6073            true = self._parse_assignment()
6074            false = self._parse_assignment() if self._match(TokenType.ELSE) else None
6075            self._match(TokenType.END)
6076            this = self.expression(exp.If, this=condition, true=true, false=false)
6077
6078        return this
6079
6080    def _parse_next_value_for(self) -> t.Optional[exp.Expression]:
6081        if not self._match_text_seq("VALUE", "FOR"):
6082            self._retreat(self._index - 1)
6083            return None
6084
6085        return self.expression(
6086            exp.NextValueFor,
6087            this=self._parse_column(),
6088            order=self._match(TokenType.OVER) and self._parse_wrapped(self._parse_order),
6089        )
6090
6091    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
6092        this = self._parse_function() or self._parse_var_or_string(upper=True)
6093
6094        if self._match(TokenType.FROM):
6095            return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
6096
6097        if not self._match(TokenType.COMMA):
6098            self.raise_error("Expected FROM or comma after EXTRACT", self._prev)
6099
6100        return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
6101
6102    def _parse_gap_fill(self) -> exp.GapFill:
6103        self._match(TokenType.TABLE)
6104        this = self._parse_table()
6105
6106        self._match(TokenType.COMMA)
6107        args = [this, *self._parse_csv(self._parse_lambda)]
6108
6109        gap_fill = exp.GapFill.from_arg_list(args)
6110        return self.validate_expression(gap_fill, args)
6111
6112    def _parse_cast(self, strict: bool, safe: t.Optional[bool] = None) -> exp.Expression:
6113        this = self._parse_assignment()
6114
6115        if not self._match(TokenType.ALIAS):
6116            if self._match(TokenType.COMMA):
6117                return self.expression(exp.CastToStrType, this=this, to=self._parse_string())
6118
6119            self.raise_error("Expected AS after CAST")
6120
6121        fmt = None
6122        to = self._parse_types()
6123
6124        default = self._match(TokenType.DEFAULT)
6125        if default:
6126            default = self._parse_bitwise()
6127            self._match_text_seq("ON", "CONVERSION", "ERROR")
6128
6129        if self._match_set((TokenType.FORMAT, TokenType.COMMA)):
6130            fmt_string = self._parse_string()
6131            fmt = self._parse_at_time_zone(fmt_string)
6132
6133            if not to:
6134                to = exp.DataType.build(exp.DataType.Type.UNKNOWN)
6135            if to.this in exp.DataType.TEMPORAL_TYPES:
6136                this = self.expression(
6137                    exp.StrToDate if to.this == exp.DataType.Type.DATE else exp.StrToTime,
6138                    this=this,
6139                    format=exp.Literal.string(
6140                        format_time(
6141                            fmt_string.this if fmt_string else "",
6142                            self.dialect.FORMAT_MAPPING or self.dialect.TIME_MAPPING,
6143                            self.dialect.FORMAT_TRIE or self.dialect.TIME_TRIE,
6144                        )
6145                    ),
6146                    safe=safe,
6147                )
6148
6149                if isinstance(fmt, exp.AtTimeZone) and isinstance(this, exp.StrToTime):
6150                    this.set("zone", fmt.args["zone"])
6151                return this
6152        elif not to:
6153            self.raise_error("Expected TYPE after CAST")
6154        elif isinstance(to, exp.Identifier):
6155            to = exp.DataType.build(to.name, udt=True)
6156        elif to.this == exp.DataType.Type.CHAR:
6157            if self._match(TokenType.CHARACTER_SET):
6158                to = self.expression(exp.CharacterSet, this=self._parse_var_or_string())
6159
6160        return self.expression(
6161            exp.Cast if strict else exp.TryCast,
6162            this=this,
6163            to=to,
6164            format=fmt,
6165            safe=safe,
6166            action=self._parse_var_from_options(self.CAST_ACTIONS, raise_unmatched=False),
6167            default=default,
6168        )
6169
6170    def _parse_string_agg(self) -> exp.GroupConcat:
6171        if self._match(TokenType.DISTINCT):
6172            args: t.List[t.Optional[exp.Expression]] = [
6173                self.expression(exp.Distinct, expressions=[self._parse_assignment()])
6174            ]
6175            if self._match(TokenType.COMMA):
6176                args.extend(self._parse_csv(self._parse_assignment))
6177        else:
6178            args = self._parse_csv(self._parse_assignment)  # type: ignore
6179
6180        if self._match_text_seq("ON", "OVERFLOW"):
6181            # trino: LISTAGG(expression [, separator] [ON OVERFLOW overflow_behavior])
6182            if self._match_text_seq("ERROR"):
6183                on_overflow: t.Optional[exp.Expression] = exp.var("ERROR")
6184            else:
6185                self._match_text_seq("TRUNCATE")
6186                on_overflow = self.expression(
6187                    exp.OverflowTruncateBehavior,
6188                    this=self._parse_string(),
6189                    with_count=(
6190                        self._match_text_seq("WITH", "COUNT")
6191                        or not self._match_text_seq("WITHOUT", "COUNT")
6192                    ),
6193                )
6194        else:
6195            on_overflow = None
6196
6197        index = self._index
6198        if not self._match(TokenType.R_PAREN) and args:
6199            # postgres: STRING_AGG([DISTINCT] expression, separator [ORDER BY expression1 {ASC | DESC} [, ...]])
6200            # bigquery: STRING_AGG([DISTINCT] expression [, separator] [ORDER BY key [{ASC | DESC}] [, ... ]] [LIMIT n])
6201            args[-1] = self._parse_limit(this=self._parse_order(this=args[-1]))
6202            return self.expression(exp.GroupConcat, this=args[0], separator=seq_get(args, 1))
6203
6204        # Checks if we can parse an order clause: WITHIN GROUP (ORDER BY <order_by_expression_list> [ASC | DESC]).
6205        # This is done "manually", instead of letting _parse_window parse it into an exp.WithinGroup node, so that
6206        # the STRING_AGG call is parsed like in MySQL / SQLite and can thus be transpiled more easily to them.
6207        if not self._match_text_seq("WITHIN", "GROUP"):
6208            self._retreat(index)
6209            return self.validate_expression(exp.GroupConcat.from_arg_list(args), args)
6210
6211        # The corresponding match_r_paren will be called in parse_function (caller)
6212        self._match_l_paren()
6213
6214        return self.expression(
6215            exp.GroupConcat,
6216            this=self._parse_order(this=seq_get(args, 0)),
6217            separator=seq_get(args, 1),
6218            on_overflow=on_overflow,
6219        )
6220
6221    def _parse_convert(
6222        self, strict: bool, safe: t.Optional[bool] = None
6223    ) -> t.Optional[exp.Expression]:
6224        this = self._parse_bitwise()
6225
6226        if self._match(TokenType.USING):
6227            to: t.Optional[exp.Expression] = self.expression(
6228                exp.CharacterSet, this=self._parse_var()
6229            )
6230        elif self._match(TokenType.COMMA):
6231            to = self._parse_types()
6232        else:
6233            to = None
6234
6235        return self.expression(exp.Cast if strict else exp.TryCast, this=this, to=to, safe=safe)
6236
6237    def _parse_xml_table(self) -> exp.XMLTable:
6238        namespaces = None
6239        passing = None
6240        columns = None
6241
6242        if self._match_text_seq("XMLNAMESPACES", "("):
6243            namespaces = self._parse_xml_namespace()
6244            self._match_text_seq(")", ",")
6245
6246        this = self._parse_string()
6247
6248        if self._match_text_seq("PASSING"):
6249            # The BY VALUE keywords are optional and are provided for semantic clarity
6250            self._match_text_seq("BY", "VALUE")
6251            passing = self._parse_csv(self._parse_column)
6252
6253        by_ref = self._match_text_seq("RETURNING", "SEQUENCE", "BY", "REF")
6254
6255        if self._match_text_seq("COLUMNS"):
6256            columns = self._parse_csv(self._parse_field_def)
6257
6258        return self.expression(
6259            exp.XMLTable,
6260            this=this,
6261            namespaces=namespaces,
6262            passing=passing,
6263            columns=columns,
6264            by_ref=by_ref,
6265        )
6266
6267    def _parse_xml_namespace(self) -> t.List[exp.XMLNamespace]:
6268        namespaces = []
6269
6270        while True:
6271            if self._match(TokenType.DEFAULT):
6272                uri = self._parse_string()
6273            else:
6274                uri = self._parse_alias(self._parse_string())
6275            namespaces.append(self.expression(exp.XMLNamespace, this=uri))
6276            if not self._match(TokenType.COMMA):
6277                break
6278
6279        return namespaces
6280
6281    def _parse_decode(self) -> t.Optional[exp.Decode | exp.Case]:
6282        """
6283        There are generally two variants of the DECODE function:
6284
6285        - DECODE(bin, charset)
6286        - DECODE(expression, search, result [, search, result] ... [, default])
6287
6288        The second variant will always be parsed into a CASE expression. Note that NULL
6289        needs special treatment, since we need to explicitly check for it with `IS NULL`,
6290        instead of relying on pattern matching.
6291        """
6292        args = self._parse_csv(self._parse_assignment)
6293
6294        if len(args) < 3:
6295            return self.expression(exp.Decode, this=seq_get(args, 0), charset=seq_get(args, 1))
6296
6297        expression, *expressions = args
6298        if not expression:
6299            return None
6300
6301        ifs = []
6302        for search, result in zip(expressions[::2], expressions[1::2]):
6303            if not search or not result:
6304                return None
6305
6306            if isinstance(search, exp.Literal):
6307                ifs.append(
6308                    exp.If(this=exp.EQ(this=expression.copy(), expression=search), true=result)
6309                )
6310            elif isinstance(search, exp.Null):
6311                ifs.append(
6312                    exp.If(this=exp.Is(this=expression.copy(), expression=exp.Null()), true=result)
6313                )
6314            else:
6315                cond = exp.or_(
6316                    exp.EQ(this=expression.copy(), expression=search),
6317                    exp.and_(
6318                        exp.Is(this=expression.copy(), expression=exp.Null()),
6319                        exp.Is(this=search.copy(), expression=exp.Null()),
6320                        copy=False,
6321                    ),
6322                    copy=False,
6323                )
6324                ifs.append(exp.If(this=cond, true=result))
6325
6326        return exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
6327
6328    def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]:
6329        self._match_text_seq("KEY")
6330        key = self._parse_column()
6331        self._match_set(self.JSON_KEY_VALUE_SEPARATOR_TOKENS)
6332        self._match_text_seq("VALUE")
6333        value = self._parse_bitwise()
6334
6335        if not key and not value:
6336            return None
6337        return self.expression(exp.JSONKeyValue, this=key, expression=value)
6338
6339    def _parse_format_json(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6340        if not this or not self._match_text_seq("FORMAT", "JSON"):
6341            return this
6342
6343        return self.expression(exp.FormatJson, this=this)
6344
6345    def _parse_on_condition(self) -> t.Optional[exp.OnCondition]:
6346        # MySQL uses "X ON EMPTY Y ON ERROR" (e.g. JSON_VALUE) while Oracle uses the opposite (e.g. JSON_EXISTS)
6347        if self.dialect.ON_CONDITION_EMPTY_BEFORE_ERROR:
6348            empty = self._parse_on_handling("EMPTY", *self.ON_CONDITION_TOKENS)
6349            error = self._parse_on_handling("ERROR", *self.ON_CONDITION_TOKENS)
6350        else:
6351            error = self._parse_on_handling("ERROR", *self.ON_CONDITION_TOKENS)
6352            empty = self._parse_on_handling("EMPTY", *self.ON_CONDITION_TOKENS)
6353
6354        null = self._parse_on_handling("NULL", *self.ON_CONDITION_TOKENS)
6355
6356        if not empty and not error and not null:
6357            return None
6358
6359        return self.expression(
6360            exp.OnCondition,
6361            empty=empty,
6362            error=error,
6363            null=null,
6364        )
6365
6366    def _parse_on_handling(
6367        self, on: str, *values: str
6368    ) -> t.Optional[str] | t.Optional[exp.Expression]:
6369        # Parses the "X ON Y" or "DEFAULT <expr> ON Y syntax, e.g. NULL ON NULL (Oracle, T-SQL, MySQL)
6370        for value in values:
6371            if self._match_text_seq(value, "ON", on):
6372                return f"{value} ON {on}"
6373
6374        index = self._index
6375        if self._match(TokenType.DEFAULT):
6376            default_value = self._parse_bitwise()
6377            if self._match_text_seq("ON", on):
6378                return default_value
6379
6380            self._retreat(index)
6381
6382        return None
6383
6384    @t.overload
6385    def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject: ...
6386
6387    @t.overload
6388    def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg: ...
6389
6390    def _parse_json_object(self, agg=False):
6391        star = self._parse_star()
6392        expressions = (
6393            [star]
6394            if star
6395            else self._parse_csv(lambda: self._parse_format_json(self._parse_json_key_value()))
6396        )
6397        null_handling = self._parse_on_handling("NULL", "NULL", "ABSENT")
6398
6399        unique_keys = None
6400        if self._match_text_seq("WITH", "UNIQUE"):
6401            unique_keys = True
6402        elif self._match_text_seq("WITHOUT", "UNIQUE"):
6403            unique_keys = False
6404
6405        self._match_text_seq("KEYS")
6406
6407        return_type = self._match_text_seq("RETURNING") and self._parse_format_json(
6408            self._parse_type()
6409        )
6410        encoding = self._match_text_seq("ENCODING") and self._parse_var()
6411
6412        return self.expression(
6413            exp.JSONObjectAgg if agg else exp.JSONObject,
6414            expressions=expressions,
6415            null_handling=null_handling,
6416            unique_keys=unique_keys,
6417            return_type=return_type,
6418            encoding=encoding,
6419        )
6420
6421    # Note: this is currently incomplete; it only implements the "JSON_value_column" part
6422    def _parse_json_column_def(self) -> exp.JSONColumnDef:
6423        if not self._match_text_seq("NESTED"):
6424            this = self._parse_id_var()
6425            kind = self._parse_types(allow_identifiers=False)
6426            nested = None
6427        else:
6428            this = None
6429            kind = None
6430            nested = True
6431
6432        path = self._match_text_seq("PATH") and self._parse_string()
6433        nested_schema = nested and self._parse_json_schema()
6434
6435        return self.expression(
6436            exp.JSONColumnDef,
6437            this=this,
6438            kind=kind,
6439            path=path,
6440            nested_schema=nested_schema,
6441        )
6442
6443    def _parse_json_schema(self) -> exp.JSONSchema:
6444        self._match_text_seq("COLUMNS")
6445        return self.expression(
6446            exp.JSONSchema,
6447            expressions=self._parse_wrapped_csv(self._parse_json_column_def, optional=True),
6448        )
6449
6450    def _parse_json_table(self) -> exp.JSONTable:
6451        this = self._parse_format_json(self._parse_bitwise())
6452        path = self._match(TokenType.COMMA) and self._parse_string()
6453        error_handling = self._parse_on_handling("ERROR", "ERROR", "NULL")
6454        empty_handling = self._parse_on_handling("EMPTY", "ERROR", "NULL")
6455        schema = self._parse_json_schema()
6456
6457        return exp.JSONTable(
6458            this=this,
6459            schema=schema,
6460            path=path,
6461            error_handling=error_handling,
6462            empty_handling=empty_handling,
6463        )
6464
6465    def _parse_match_against(self) -> exp.MatchAgainst:
6466        expressions = self._parse_csv(self._parse_column)
6467
6468        self._match_text_seq(")", "AGAINST", "(")
6469
6470        this = self._parse_string()
6471
6472        if self._match_text_seq("IN", "NATURAL", "LANGUAGE", "MODE"):
6473            modifier = "IN NATURAL LANGUAGE MODE"
6474            if self._match_text_seq("WITH", "QUERY", "EXPANSION"):
6475                modifier = f"{modifier} WITH QUERY EXPANSION"
6476        elif self._match_text_seq("IN", "BOOLEAN", "MODE"):
6477            modifier = "IN BOOLEAN MODE"
6478        elif self._match_text_seq("WITH", "QUERY", "EXPANSION"):
6479            modifier = "WITH QUERY EXPANSION"
6480        else:
6481            modifier = None
6482
6483        return self.expression(
6484            exp.MatchAgainst, this=this, expressions=expressions, modifier=modifier
6485        )
6486
6487    # https://learn.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql?view=sql-server-ver16
6488    def _parse_open_json(self) -> exp.OpenJSON:
6489        this = self._parse_bitwise()
6490        path = self._match(TokenType.COMMA) and self._parse_string()
6491
6492        def _parse_open_json_column_def() -> exp.OpenJSONColumnDef:
6493            this = self._parse_field(any_token=True)
6494            kind = self._parse_types()
6495            path = self._parse_string()
6496            as_json = self._match_pair(TokenType.ALIAS, TokenType.JSON)
6497
6498            return self.expression(
6499                exp.OpenJSONColumnDef, this=this, kind=kind, path=path, as_json=as_json
6500            )
6501
6502        expressions = None
6503        if self._match_pair(TokenType.R_PAREN, TokenType.WITH):
6504            self._match_l_paren()
6505            expressions = self._parse_csv(_parse_open_json_column_def)
6506
6507        return self.expression(exp.OpenJSON, this=this, path=path, expressions=expressions)
6508
6509    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
6510        args = self._parse_csv(self._parse_bitwise)
6511
6512        if self._match(TokenType.IN):
6513            return self.expression(
6514                exp.StrPosition, this=self._parse_bitwise(), substr=seq_get(args, 0)
6515            )
6516
6517        if haystack_first:
6518            haystack = seq_get(args, 0)
6519            needle = seq_get(args, 1)
6520        else:
6521            haystack = seq_get(args, 1)
6522            needle = seq_get(args, 0)
6523
6524        return self.expression(
6525            exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2)
6526        )
6527
6528    def _parse_predict(self) -> exp.Predict:
6529        self._match_text_seq("MODEL")
6530        this = self._parse_table()
6531
6532        self._match(TokenType.COMMA)
6533        self._match_text_seq("TABLE")
6534
6535        return self.expression(
6536            exp.Predict,
6537            this=this,
6538            expression=self._parse_table(),
6539            params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
6540        )
6541
6542    def _parse_join_hint(self, func_name: str) -> exp.JoinHint:
6543        args = self._parse_csv(self._parse_table)
6544        return exp.JoinHint(this=func_name.upper(), expressions=args)
6545
6546    def _parse_substring(self) -> exp.Substring:
6547        # Postgres supports the form: substring(string [from int] [for int])
6548        # https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
6549
6550        args = t.cast(t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_bitwise))
6551
6552        if self._match(TokenType.FROM):
6553            args.append(self._parse_bitwise())
6554        if self._match(TokenType.FOR):
6555            if len(args) == 1:
6556                args.append(exp.Literal.number(1))
6557            args.append(self._parse_bitwise())
6558
6559        return self.validate_expression(exp.Substring.from_arg_list(args), args)
6560
6561    def _parse_trim(self) -> exp.Trim:
6562        # https://www.w3resource.com/sql/character-functions/trim.php
6563        # https://docs.oracle.com/javadb/10.8.3.0/ref/rreftrimfunc.html
6564
6565        position = None
6566        collation = None
6567        expression = None
6568
6569        if self._match_texts(self.TRIM_TYPES):
6570            position = self._prev.text.upper()
6571
6572        this = self._parse_bitwise()
6573        if self._match_set((TokenType.FROM, TokenType.COMMA)):
6574            invert_order = self._prev.token_type == TokenType.FROM or self.TRIM_PATTERN_FIRST
6575            expression = self._parse_bitwise()
6576
6577            if invert_order:
6578                this, expression = expression, this
6579
6580        if self._match(TokenType.COLLATE):
6581            collation = self._parse_bitwise()
6582
6583        return self.expression(
6584            exp.Trim, this=this, position=position, expression=expression, collation=collation
6585        )
6586
6587    def _parse_window_clause(self) -> t.Optional[t.List[exp.Expression]]:
6588        return self._match(TokenType.WINDOW) and self._parse_csv(self._parse_named_window)
6589
6590    def _parse_named_window(self) -> t.Optional[exp.Expression]:
6591        return self._parse_window(self._parse_id_var(), alias=True)
6592
6593    def _parse_respect_or_ignore_nulls(
6594        self, this: t.Optional[exp.Expression]
6595    ) -> t.Optional[exp.Expression]:
6596        if self._match_text_seq("IGNORE", "NULLS"):
6597            return self.expression(exp.IgnoreNulls, this=this)
6598        if self._match_text_seq("RESPECT", "NULLS"):
6599            return self.expression(exp.RespectNulls, this=this)
6600        return this
6601
6602    def _parse_having_max(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6603        if self._match(TokenType.HAVING):
6604            self._match_texts(("MAX", "MIN"))
6605            max = self._prev.text.upper() != "MIN"
6606            return self.expression(
6607                exp.HavingMax, this=this, expression=self._parse_column(), max=max
6608            )
6609
6610        return this
6611
6612    def _parse_window(
6613        self, this: t.Optional[exp.Expression], alias: bool = False
6614    ) -> t.Optional[exp.Expression]:
6615        func = this
6616        comments = func.comments if isinstance(func, exp.Expression) else None
6617
6618        # T-SQL allows the OVER (...) syntax after WITHIN GROUP.
6619        # https://learn.microsoft.com/en-us/sql/t-sql/functions/percentile-disc-transact-sql?view=sql-server-ver16
6620        if self._match_text_seq("WITHIN", "GROUP"):
6621            order = self._parse_wrapped(self._parse_order)
6622            this = self.expression(exp.WithinGroup, this=this, expression=order)
6623
6624        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
6625            self._match(TokenType.WHERE)
6626            this = self.expression(
6627                exp.Filter, this=this, expression=self._parse_where(skip_where_token=True)
6628            )
6629            self._match_r_paren()
6630
6631        # SQL spec defines an optional [ { IGNORE | RESPECT } NULLS ] OVER
6632        # Some dialects choose to implement and some do not.
6633        # https://dev.mysql.com/doc/refman/8.0/en/window-function-descriptions.html
6634
6635        # There is some code above in _parse_lambda that handles
6636        #   SELECT FIRST_VALUE(TABLE.COLUMN IGNORE|RESPECT NULLS) OVER ...
6637
6638        # The below changes handle
6639        #   SELECT FIRST_VALUE(TABLE.COLUMN) IGNORE|RESPECT NULLS OVER ...
6640
6641        # Oracle allows both formats
6642        #   (https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/first_value.html)
6643        #   and Snowflake chose to do the same for familiarity
6644        #   https://docs.snowflake.com/en/sql-reference/functions/first_value.html#usage-notes
6645        if isinstance(this, exp.AggFunc):
6646            ignore_respect = this.find(exp.IgnoreNulls, exp.RespectNulls)
6647
6648            if ignore_respect and ignore_respect is not this:
6649                ignore_respect.replace(ignore_respect.this)
6650                this = self.expression(ignore_respect.__class__, this=this)
6651
6652        this = self._parse_respect_or_ignore_nulls(this)
6653
6654        # bigquery select from window x AS (partition by ...)
6655        if alias:
6656            over = None
6657            self._match(TokenType.ALIAS)
6658        elif not self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS):
6659            return this
6660        else:
6661            over = self._prev.text.upper()
6662
6663        if comments and isinstance(func, exp.Expression):
6664            func.pop_comments()
6665
6666        if not self._match(TokenType.L_PAREN):
6667            return self.expression(
6668                exp.Window,
6669                comments=comments,
6670                this=this,
6671                alias=self._parse_id_var(False),
6672                over=over,
6673            )
6674
6675        window_alias = self._parse_id_var(any_token=False, tokens=self.WINDOW_ALIAS_TOKENS)
6676
6677        first = self._match(TokenType.FIRST)
6678        if self._match_text_seq("LAST"):
6679            first = False
6680
6681        partition, order = self._parse_partition_and_order()
6682        kind = self._match_set((TokenType.ROWS, TokenType.RANGE)) and self._prev.text
6683
6684        if kind:
6685            self._match(TokenType.BETWEEN)
6686            start = self._parse_window_spec()
6687            self._match(TokenType.AND)
6688            end = self._parse_window_spec()
6689
6690            spec = self.expression(
6691                exp.WindowSpec,
6692                kind=kind,
6693                start=start["value"],
6694                start_side=start["side"],
6695                end=end["value"],
6696                end_side=end["side"],
6697            )
6698        else:
6699            spec = None
6700
6701        self._match_r_paren()
6702
6703        window = self.expression(
6704            exp.Window,
6705            comments=comments,
6706            this=this,
6707            partition_by=partition,
6708            order=order,
6709            spec=spec,
6710            alias=window_alias,
6711            over=over,
6712            first=first,
6713        )
6714
6715        # This covers Oracle's FIRST/LAST syntax: aggregate KEEP (...) OVER (...)
6716        if self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS, advance=False):
6717            return self._parse_window(window, alias=alias)
6718
6719        return window
6720
6721    def _parse_partition_and_order(
6722        self,
6723    ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
6724        return self._parse_partition_by(), self._parse_order()
6725
6726    def _parse_window_spec(self) -> t.Dict[str, t.Optional[str | exp.Expression]]:
6727        self._match(TokenType.BETWEEN)
6728
6729        return {
6730            "value": (
6731                (self._match_text_seq("UNBOUNDED") and "UNBOUNDED")
6732                or (self._match_text_seq("CURRENT", "ROW") and "CURRENT ROW")
6733                or self._parse_bitwise()
6734            ),
6735            "side": self._match_texts(self.WINDOW_SIDES) and self._prev.text,
6736        }
6737
6738    def _parse_alias(
6739        self, this: t.Optional[exp.Expression], explicit: bool = False
6740    ) -> t.Optional[exp.Expression]:
6741        # In some dialects, LIMIT and OFFSET can act as both identifiers and keywords (clauses)
6742        # so this section tries to parse the clause version and if it fails, it treats the token
6743        # as an identifier (alias)
6744        if self._can_parse_limit_or_offset():
6745            return this
6746
6747        any_token = self._match(TokenType.ALIAS)
6748        comments = self._prev_comments or []
6749
6750        if explicit and not any_token:
6751            return this
6752
6753        if self._match(TokenType.L_PAREN):
6754            aliases = self.expression(
6755                exp.Aliases,
6756                comments=comments,
6757                this=this,
6758                expressions=self._parse_csv(lambda: self._parse_id_var(any_token)),
6759            )
6760            self._match_r_paren(aliases)
6761            return aliases
6762
6763        alias = self._parse_id_var(any_token, tokens=self.ALIAS_TOKENS) or (
6764            self.STRING_ALIASES and self._parse_string_as_identifier()
6765        )
6766
6767        if alias:
6768            comments.extend(alias.pop_comments())
6769            this = self.expression(exp.Alias, comments=comments, this=this, alias=alias)
6770            column = this.this
6771
6772            # Moves the comment next to the alias in `expr /* comment */ AS alias`
6773            if not this.comments and column and column.comments:
6774                this.comments = column.pop_comments()
6775
6776        return this
6777
6778    def _parse_id_var(
6779        self,
6780        any_token: bool = True,
6781        tokens: t.Optional[t.Collection[TokenType]] = None,
6782    ) -> t.Optional[exp.Expression]:
6783        expression = self._parse_identifier()
6784        if not expression and (
6785            (any_token and self._advance_any()) or self._match_set(tokens or self.ID_VAR_TOKENS)
6786        ):
6787            quoted = self._prev.token_type == TokenType.STRING
6788            expression = self.expression(exp.Identifier, this=self._prev.text, quoted=quoted)
6789
6790        return expression
6791
6792    def _parse_string(self) -> t.Optional[exp.Expression]:
6793        if self._match_set(self.STRING_PARSERS):
6794            return self.STRING_PARSERS[self._prev.token_type](self, self._prev)
6795        return self._parse_placeholder()
6796
6797    def _parse_string_as_identifier(self) -> t.Optional[exp.Identifier]:
6798        return exp.to_identifier(self._match(TokenType.STRING) and self._prev.text, quoted=True)
6799
6800    def _parse_number(self) -> t.Optional[exp.Expression]:
6801        if self._match_set(self.NUMERIC_PARSERS):
6802            return self.NUMERIC_PARSERS[self._prev.token_type](self, self._prev)
6803        return self._parse_placeholder()
6804
6805    def _parse_identifier(self) -> t.Optional[exp.Expression]:
6806        if self._match(TokenType.IDENTIFIER):
6807            return self.expression(exp.Identifier, this=self._prev.text, quoted=True)
6808        return self._parse_placeholder()
6809
6810    def _parse_var(
6811        self,
6812        any_token: bool = False,
6813        tokens: t.Optional[t.Collection[TokenType]] = None,
6814        upper: bool = False,
6815    ) -> t.Optional[exp.Expression]:
6816        if (
6817            (any_token and self._advance_any())
6818            or self._match(TokenType.VAR)
6819            or (self._match_set(tokens) if tokens else False)
6820        ):
6821            return self.expression(
6822                exp.Var, this=self._prev.text.upper() if upper else self._prev.text
6823            )
6824        return self._parse_placeholder()
6825
6826    def _advance_any(self, ignore_reserved: bool = False) -> t.Optional[Token]:
6827        if self._curr and (ignore_reserved or self._curr.token_type not in self.RESERVED_TOKENS):
6828            self._advance()
6829            return self._prev
6830        return None
6831
6832    def _parse_var_or_string(self, upper: bool = False) -> t.Optional[exp.Expression]:
6833        return self._parse_string() or self._parse_var(any_token=True, upper=upper)
6834
6835    def _parse_primary_or_var(self) -> t.Optional[exp.Expression]:
6836        return self._parse_primary() or self._parse_var(any_token=True)
6837
6838    def _parse_null(self) -> t.Optional[exp.Expression]:
6839        if self._match_set(self.NULL_TOKENS):
6840            return self.PRIMARY_PARSERS[TokenType.NULL](self, self._prev)
6841        return self._parse_placeholder()
6842
6843    def _parse_boolean(self) -> t.Optional[exp.Expression]:
6844        if self._match(TokenType.TRUE):
6845            return self.PRIMARY_PARSERS[TokenType.TRUE](self, self._prev)
6846        if self._match(TokenType.FALSE):
6847            return self.PRIMARY_PARSERS[TokenType.FALSE](self, self._prev)
6848        return self._parse_placeholder()
6849
6850    def _parse_star(self) -> t.Optional[exp.Expression]:
6851        if self._match(TokenType.STAR):
6852            return self.PRIMARY_PARSERS[TokenType.STAR](self, self._prev)
6853        return self._parse_placeholder()
6854
6855    def _parse_parameter(self) -> exp.Parameter:
6856        this = self._parse_identifier() or self._parse_primary_or_var()
6857        return self.expression(exp.Parameter, this=this)
6858
6859    def _parse_placeholder(self) -> t.Optional[exp.Expression]:
6860        if self._match_set(self.PLACEHOLDER_PARSERS):
6861            placeholder = self.PLACEHOLDER_PARSERS[self._prev.token_type](self)
6862            if placeholder:
6863                return placeholder
6864            self._advance(-1)
6865        return None
6866
6867    def _parse_star_op(self, *keywords: str) -> t.Optional[t.List[exp.Expression]]:
6868        if not self._match_texts(keywords):
6869            return None
6870        if self._match(TokenType.L_PAREN, advance=False):
6871            return self._parse_wrapped_csv(self._parse_expression)
6872
6873        expression = self._parse_expression()
6874        return [expression] if expression else None
6875
6876    def _parse_csv(
6877        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA
6878    ) -> t.List[exp.Expression]:
6879        parse_result = parse_method()
6880        items = [parse_result] if parse_result is not None else []
6881
6882        while self._match(sep):
6883            self._add_comments(parse_result)
6884            parse_result = parse_method()
6885            if parse_result is not None:
6886                items.append(parse_result)
6887
6888        return items
6889
6890    def _parse_tokens(
6891        self, parse_method: t.Callable, expressions: t.Dict
6892    ) -> t.Optional[exp.Expression]:
6893        this = parse_method()
6894
6895        while self._match_set(expressions):
6896            this = self.expression(
6897                expressions[self._prev.token_type],
6898                this=this,
6899                comments=self._prev_comments,
6900                expression=parse_method(),
6901            )
6902
6903        return this
6904
6905    def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
6906        return self._parse_wrapped_csv(self._parse_id_var, optional=optional)
6907
6908    def _parse_wrapped_csv(
6909        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA, optional: bool = False
6910    ) -> t.List[exp.Expression]:
6911        return self._parse_wrapped(
6912            lambda: self._parse_csv(parse_method, sep=sep), optional=optional
6913        )
6914
6915    def _parse_wrapped(self, parse_method: t.Callable, optional: bool = False) -> t.Any:
6916        wrapped = self._match(TokenType.L_PAREN)
6917        if not wrapped and not optional:
6918            self.raise_error("Expecting (")
6919        parse_result = parse_method()
6920        if wrapped:
6921            self._match_r_paren()
6922        return parse_result
6923
6924    def _parse_expressions(self) -> t.List[exp.Expression]:
6925        return self._parse_csv(self._parse_expression)
6926
6927    def _parse_select_or_expression(self, alias: bool = False) -> t.Optional[exp.Expression]:
6928        return self._parse_select() or self._parse_set_operations(
6929            self._parse_alias(self._parse_assignment(), explicit=True)
6930            if alias
6931            else self._parse_assignment()
6932        )
6933
6934    def _parse_ddl_select(self) -> t.Optional[exp.Expression]:
6935        return self._parse_query_modifiers(
6936            self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False))
6937        )
6938
6939    def _parse_transaction(self) -> exp.Transaction | exp.Command:
6940        this = None
6941        if self._match_texts(self.TRANSACTION_KIND):
6942            this = self._prev.text
6943
6944        self._match_texts(("TRANSACTION", "WORK"))
6945
6946        modes = []
6947        while True:
6948            mode = []
6949            while self._match(TokenType.VAR):
6950                mode.append(self._prev.text)
6951
6952            if mode:
6953                modes.append(" ".join(mode))
6954            if not self._match(TokenType.COMMA):
6955                break
6956
6957        return self.expression(exp.Transaction, this=this, modes=modes)
6958
6959    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
6960        chain = None
6961        savepoint = None
6962        is_rollback = self._prev.token_type == TokenType.ROLLBACK
6963
6964        self._match_texts(("TRANSACTION", "WORK"))
6965
6966        if self._match_text_seq("TO"):
6967            self._match_text_seq("SAVEPOINT")
6968            savepoint = self._parse_id_var()
6969
6970        if self._match(TokenType.AND):
6971            chain = not self._match_text_seq("NO")
6972            self._match_text_seq("CHAIN")
6973
6974        if is_rollback:
6975            return self.expression(exp.Rollback, savepoint=savepoint)
6976
6977        return self.expression(exp.Commit, chain=chain)
6978
6979    def _parse_refresh(self) -> exp.Refresh:
6980        self._match(TokenType.TABLE)
6981        return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table())
6982
6983    def _parse_add_column(self) -> t.Optional[exp.Expression]:
6984        if not self._match_text_seq("ADD"):
6985            return None
6986
6987        self._match(TokenType.COLUMN)
6988        exists_column = self._parse_exists(not_=True)
6989        expression = self._parse_field_def()
6990
6991        if expression:
6992            expression.set("exists", exists_column)
6993
6994            # https://docs.databricks.com/delta/update-schema.html#explicitly-update-schema-to-add-columns
6995            if self._match_texts(("FIRST", "AFTER")):
6996                position = self._prev.text
6997                column_position = self.expression(
6998                    exp.ColumnPosition, this=self._parse_column(), position=position
6999                )
7000                expression.set("position", column_position)
7001
7002        return expression
7003
7004    def _parse_drop_column(self) -> t.Optional[exp.Drop | exp.Command]:
7005        drop = self._match(TokenType.DROP) and self._parse_drop()
7006        if drop and not isinstance(drop, exp.Command):
7007            drop.set("kind", drop.args.get("kind", "COLUMN"))
7008        return drop
7009
7010    # https://docs.aws.amazon.com/athena/latest/ug/alter-table-drop-partition.html
7011    def _parse_drop_partition(self, exists: t.Optional[bool] = None) -> exp.DropPartition:
7012        return self.expression(
7013            exp.DropPartition, expressions=self._parse_csv(self._parse_partition), exists=exists
7014        )
7015
7016    def _parse_alter_table_add(self) -> t.List[exp.Expression]:
7017        index = self._index - 1
7018
7019        if self._match_set(self.ADD_CONSTRAINT_TOKENS, advance=False):
7020            return self._parse_csv(
7021                lambda: self.expression(
7022                    exp.AddConstraint, expressions=self._parse_csv(self._parse_constraint)
7023                )
7024            )
7025
7026        self._retreat(index)
7027        if not self.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and self._match_text_seq("ADD"):
7028            return self._parse_wrapped_csv(self._parse_field_def, optional=True)
7029
7030        if self._match_text_seq("ADD", "COLUMNS"):
7031            schema = self._parse_schema()
7032            if schema:
7033                return [schema]
7034            return []
7035
7036        return self._parse_wrapped_csv(self._parse_add_column, optional=True)
7037
7038    def _parse_alter_table_alter(self) -> t.Optional[exp.Expression]:
7039        if self._match_texts(self.ALTER_ALTER_PARSERS):
7040            return self.ALTER_ALTER_PARSERS[self._prev.text.upper()](self)
7041
7042        # Many dialects support the ALTER [COLUMN] syntax, so if there is no
7043        # keyword after ALTER we default to parsing this statement
7044        self._match(TokenType.COLUMN)
7045        column = self._parse_field(any_token=True)
7046
7047        if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
7048            return self.expression(exp.AlterColumn, this=column, drop=True)
7049        if self._match_pair(TokenType.SET, TokenType.DEFAULT):
7050            return self.expression(exp.AlterColumn, this=column, default=self._parse_assignment())
7051        if self._match(TokenType.COMMENT):
7052            return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
7053        if self._match_text_seq("DROP", "NOT", "NULL"):
7054            return self.expression(
7055                exp.AlterColumn,
7056                this=column,
7057                drop=True,
7058                allow_null=True,
7059            )
7060        if self._match_text_seq("SET", "NOT", "NULL"):
7061            return self.expression(
7062                exp.AlterColumn,
7063                this=column,
7064                allow_null=False,
7065            )
7066        self._match_text_seq("SET", "DATA")
7067        self._match_text_seq("TYPE")
7068        return self.expression(
7069            exp.AlterColumn,
7070            this=column,
7071            dtype=self._parse_types(),
7072            collate=self._match(TokenType.COLLATE) and self._parse_term(),
7073            using=self._match(TokenType.USING) and self._parse_assignment(),
7074        )
7075
7076    def _parse_alter_diststyle(self) -> exp.AlterDistStyle:
7077        if self._match_texts(("ALL", "EVEN", "AUTO")):
7078            return self.expression(exp.AlterDistStyle, this=exp.var(self._prev.text.upper()))
7079
7080        self._match_text_seq("KEY", "DISTKEY")
7081        return self.expression(exp.AlterDistStyle, this=self._parse_column())
7082
7083    def _parse_alter_sortkey(self, compound: t.Optional[bool] = None) -> exp.AlterSortKey:
7084        if compound:
7085            self._match_text_seq("SORTKEY")
7086
7087        if self._match(TokenType.L_PAREN, advance=False):
7088            return self.expression(
7089                exp.AlterSortKey, expressions=self._parse_wrapped_id_vars(), compound=compound
7090            )
7091
7092        self._match_texts(("AUTO", "NONE"))
7093        return self.expression(
7094            exp.AlterSortKey, this=exp.var(self._prev.text.upper()), compound=compound
7095        )
7096
7097    def _parse_alter_table_drop(self) -> t.List[exp.Expression]:
7098        index = self._index - 1
7099
7100        partition_exists = self._parse_exists()
7101        if self._match(TokenType.PARTITION, advance=False):
7102            return self._parse_csv(lambda: self._parse_drop_partition(exists=partition_exists))
7103
7104        self._retreat(index)
7105        return self._parse_csv(self._parse_drop_column)
7106
7107    def _parse_alter_table_rename(self) -> t.Optional[exp.AlterRename | exp.RenameColumn]:
7108        if self._match(TokenType.COLUMN):
7109            exists = self._parse_exists()
7110            old_column = self._parse_column()
7111            to = self._match_text_seq("TO")
7112            new_column = self._parse_column()
7113
7114            if old_column is None or to is None or new_column is None:
7115                return None
7116
7117            return self.expression(exp.RenameColumn, this=old_column, to=new_column, exists=exists)
7118
7119        self._match_text_seq("TO")
7120        return self.expression(exp.AlterRename, this=self._parse_table(schema=True))
7121
7122    def _parse_alter_table_set(self) -> exp.AlterSet:
7123        alter_set = self.expression(exp.AlterSet)
7124
7125        if self._match(TokenType.L_PAREN, advance=False) or self._match_text_seq(
7126            "TABLE", "PROPERTIES"
7127        ):
7128            alter_set.set("expressions", self._parse_wrapped_csv(self._parse_assignment))
7129        elif self._match_text_seq("FILESTREAM_ON", advance=False):
7130            alter_set.set("expressions", [self._parse_assignment()])
7131        elif self._match_texts(("LOGGED", "UNLOGGED")):
7132            alter_set.set("option", exp.var(self._prev.text.upper()))
7133        elif self._match_text_seq("WITHOUT") and self._match_texts(("CLUSTER", "OIDS")):
7134            alter_set.set("option", exp.var(f"WITHOUT {self._prev.text.upper()}"))
7135        elif self._match_text_seq("LOCATION"):
7136            alter_set.set("location", self._parse_field())
7137        elif self._match_text_seq("ACCESS", "METHOD"):
7138            alter_set.set("access_method", self._parse_field())
7139        elif self._match_text_seq("TABLESPACE"):
7140            alter_set.set("tablespace", self._parse_field())
7141        elif self._match_text_seq("FILE", "FORMAT") or self._match_text_seq("FILEFORMAT"):
7142            alter_set.set("file_format", [self._parse_field()])
7143        elif self._match_text_seq("STAGE_FILE_FORMAT"):
7144            alter_set.set("file_format", self._parse_wrapped_options())
7145        elif self._match_text_seq("STAGE_COPY_OPTIONS"):
7146            alter_set.set("copy_options", self._parse_wrapped_options())
7147        elif self._match_text_seq("TAG") or self._match_text_seq("TAGS"):
7148            alter_set.set("tag", self._parse_csv(self._parse_assignment))
7149        else:
7150            if self._match_text_seq("SERDE"):
7151                alter_set.set("serde", self._parse_field())
7152
7153            alter_set.set("expressions", [self._parse_properties()])
7154
7155        return alter_set
7156
7157    def _parse_alter(self) -> exp.Alter | exp.Command:
7158        start = self._prev
7159
7160        alter_token = self._match_set(self.ALTERABLES) and self._prev
7161        if not alter_token:
7162            return self._parse_as_command(start)
7163
7164        exists = self._parse_exists()
7165        only = self._match_text_seq("ONLY")
7166        this = self._parse_table(schema=True)
7167        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
7168
7169        if self._next:
7170            self._advance()
7171
7172        parser = self.ALTER_PARSERS.get(self._prev.text.upper()) if self._prev else None
7173        if parser:
7174            actions = ensure_list(parser(self))
7175            not_valid = self._match_text_seq("NOT", "VALID")
7176            options = self._parse_csv(self._parse_property)
7177
7178            if not self._curr and actions:
7179                return self.expression(
7180                    exp.Alter,
7181                    this=this,
7182                    kind=alter_token.text.upper(),
7183                    exists=exists,
7184                    actions=actions,
7185                    only=only,
7186                    options=options,
7187                    cluster=cluster,
7188                    not_valid=not_valid,
7189                )
7190
7191        return self._parse_as_command(start)
7192
7193    def _parse_analyze(self) -> exp.Analyze | exp.Command:
7194        start = self._prev
7195        # https://duckdb.org/docs/sql/statements/analyze
7196        if not self._curr:
7197            return self.expression(exp.Analyze)
7198
7199        options = []
7200        while self._match_texts(self.ANALYZE_STYLES):
7201            if self._prev.text.upper() == "BUFFER_USAGE_LIMIT":
7202                options.append(f"BUFFER_USAGE_LIMIT {self._parse_number()}")
7203            else:
7204                options.append(self._prev.text.upper())
7205
7206        this: t.Optional[exp.Expression] = None
7207        inner_expression: t.Optional[exp.Expression] = None
7208
7209        kind = self._curr and self._curr.text.upper()
7210
7211        if self._match(TokenType.TABLE) or self._match(TokenType.INDEX):
7212            this = self._parse_table_parts()
7213        elif self._match_text_seq("TABLES"):
7214            if self._match_set((TokenType.FROM, TokenType.IN)):
7215                kind = f"{kind} {self._prev.text.upper()}"
7216                this = self._parse_table(schema=True, is_db_reference=True)
7217        elif self._match_text_seq("DATABASE"):
7218            this = self._parse_table(schema=True, is_db_reference=True)
7219        elif self._match_text_seq("CLUSTER"):
7220            this = self._parse_table()
7221        # Try matching inner expr keywords before fallback to parse table.
7222        elif self._match_texts(self.ANALYZE_EXPRESSION_PARSERS):
7223            kind = None
7224            inner_expression = self.ANALYZE_EXPRESSION_PARSERS[self._prev.text.upper()](self)
7225        else:
7226            # Empty kind  https://prestodb.io/docs/current/sql/analyze.html
7227            kind = None
7228            this = self._parse_table_parts()
7229
7230        partition = self._try_parse(self._parse_partition)
7231        if not partition and self._match_texts(self.PARTITION_KEYWORDS):
7232            return self._parse_as_command(start)
7233
7234        # https://docs.starrocks.io/docs/sql-reference/sql-statements/cbo_stats/ANALYZE_TABLE/
7235        if self._match_text_seq("WITH", "SYNC", "MODE") or self._match_text_seq(
7236            "WITH", "ASYNC", "MODE"
7237        ):
7238            mode = f"WITH {self._tokens[self._index-2].text.upper()} MODE"
7239        else:
7240            mode = None
7241
7242        if self._match_texts(self.ANALYZE_EXPRESSION_PARSERS):
7243            inner_expression = self.ANALYZE_EXPRESSION_PARSERS[self._prev.text.upper()](self)
7244
7245        properties = self._parse_properties()
7246        return self.expression(
7247            exp.Analyze,
7248            kind=kind,
7249            this=this,
7250            mode=mode,
7251            partition=partition,
7252            properties=properties,
7253            expression=inner_expression,
7254            options=options,
7255        )
7256
7257    # https://spark.apache.org/docs/3.5.1/sql-ref-syntax-aux-analyze-table.html
7258    def _parse_analyze_statistics(self) -> exp.AnalyzeStatistics:
7259        this = None
7260        kind = self._prev.text.upper()
7261        option = self._prev.text.upper() if self._match_text_seq("DELTA") else None
7262        expressions = []
7263
7264        if not self._match_text_seq("STATISTICS"):
7265            self.raise_error("Expecting token STATISTICS")
7266
7267        if self._match_text_seq("NOSCAN"):
7268            this = "NOSCAN"
7269        elif self._match(TokenType.FOR):
7270            if self._match_text_seq("ALL", "COLUMNS"):
7271                this = "FOR ALL COLUMNS"
7272            if self._match_texts("COLUMNS"):
7273                this = "FOR COLUMNS"
7274                expressions = self._parse_csv(self._parse_column_reference)
7275        elif self._match_text_seq("SAMPLE"):
7276            sample = self._parse_number()
7277            expressions = [
7278                self.expression(
7279                    exp.AnalyzeSample,
7280                    sample=sample,
7281                    kind=self._prev.text.upper() if self._match(TokenType.PERCENT) else None,
7282                )
7283            ]
7284
7285        return self.expression(
7286            exp.AnalyzeStatistics, kind=kind, option=option, this=this, expressions=expressions
7287        )
7288
7289    # https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ANALYZE.html
7290    def _parse_analyze_validate(self) -> exp.AnalyzeValidate:
7291        kind = None
7292        this = None
7293        expression: t.Optional[exp.Expression] = None
7294        if self._match_text_seq("REF", "UPDATE"):
7295            kind = "REF"
7296            this = "UPDATE"
7297            if self._match_text_seq("SET", "DANGLING", "TO", "NULL"):
7298                this = "UPDATE SET DANGLING TO NULL"
7299        elif self._match_text_seq("STRUCTURE"):
7300            kind = "STRUCTURE"
7301            if self._match_text_seq("CASCADE", "FAST"):
7302                this = "CASCADE FAST"
7303            elif self._match_text_seq("CASCADE", "COMPLETE") and self._match_texts(
7304                ("ONLINE", "OFFLINE")
7305            ):
7306                this = f"CASCADE COMPLETE {self._prev.text.upper()}"
7307                expression = self._parse_into()
7308
7309        return self.expression(exp.AnalyzeValidate, kind=kind, this=this, expression=expression)
7310
7311    def _parse_analyze_columns(self) -> t.Optional[exp.AnalyzeColumns]:
7312        this = self._prev.text.upper()
7313        if self._match_text_seq("COLUMNS"):
7314            return self.expression(exp.AnalyzeColumns, this=f"{this} {self._prev.text.upper()}")
7315        return None
7316
7317    def _parse_analyze_delete(self) -> t.Optional[exp.AnalyzeDelete]:
7318        kind = self._prev.text.upper() if self._match_text_seq("SYSTEM") else None
7319        if self._match_text_seq("STATISTICS"):
7320            return self.expression(exp.AnalyzeDelete, kind=kind)
7321        return None
7322
7323    def _parse_analyze_list(self) -> t.Optional[exp.AnalyzeListChainedRows]:
7324        if self._match_text_seq("CHAINED", "ROWS"):
7325            return self.expression(exp.AnalyzeListChainedRows, expression=self._parse_into())
7326        return None
7327
7328    # https://dev.mysql.com/doc/refman/8.4/en/analyze-table.html
7329    def _parse_analyze_histogram(self) -> exp.AnalyzeHistogram:
7330        this = self._prev.text.upper()
7331        expression: t.Optional[exp.Expression] = None
7332        expressions = []
7333        update_options = None
7334
7335        if self._match_text_seq("HISTOGRAM", "ON"):
7336            expressions = self._parse_csv(self._parse_column_reference)
7337            with_expressions = []
7338            while self._match(TokenType.WITH):
7339                # https://docs.starrocks.io/docs/sql-reference/sql-statements/cbo_stats/ANALYZE_TABLE/
7340                if self._match_texts(("SYNC", "ASYNC")):
7341                    if self._match_text_seq("MODE", advance=False):
7342                        with_expressions.append(f"{self._prev.text.upper()} MODE")
7343                        self._advance()
7344                else:
7345                    buckets = self._parse_number()
7346                    if self._match_text_seq("BUCKETS"):
7347                        with_expressions.append(f"{buckets} BUCKETS")
7348            if with_expressions:
7349                expression = self.expression(exp.AnalyzeWith, expressions=with_expressions)
7350
7351            if self._match_texts(("MANUAL", "AUTO")) and self._match(
7352                TokenType.UPDATE, advance=False
7353            ):
7354                update_options = self._prev.text.upper()
7355                self._advance()
7356            elif self._match_text_seq("USING", "DATA"):
7357                expression = self.expression(exp.UsingData, this=self._parse_string())
7358
7359        return self.expression(
7360            exp.AnalyzeHistogram,
7361            this=this,
7362            expressions=expressions,
7363            expression=expression,
7364            update_options=update_options,
7365        )
7366
7367    def _parse_merge(self) -> exp.Merge:
7368        self._match(TokenType.INTO)
7369        target = self._parse_table()
7370
7371        if target and self._match(TokenType.ALIAS, advance=False):
7372            target.set("alias", self._parse_table_alias())
7373
7374        self._match(TokenType.USING)
7375        using = self._parse_table()
7376
7377        self._match(TokenType.ON)
7378        on = self._parse_assignment()
7379
7380        return self.expression(
7381            exp.Merge,
7382            this=target,
7383            using=using,
7384            on=on,
7385            whens=self._parse_when_matched(),
7386            returning=self._parse_returning(),
7387        )
7388
7389    def _parse_when_matched(self) -> exp.Whens:
7390        whens = []
7391
7392        while self._match(TokenType.WHEN):
7393            matched = not self._match(TokenType.NOT)
7394            self._match_text_seq("MATCHED")
7395            source = (
7396                False
7397                if self._match_text_seq("BY", "TARGET")
7398                else self._match_text_seq("BY", "SOURCE")
7399            )
7400            condition = self._parse_assignment() if self._match(TokenType.AND) else None
7401
7402            self._match(TokenType.THEN)
7403
7404            if self._match(TokenType.INSERT):
7405                this = self._parse_star()
7406                if this:
7407                    then: t.Optional[exp.Expression] = self.expression(exp.Insert, this=this)
7408                else:
7409                    then = self.expression(
7410                        exp.Insert,
7411                        this=exp.var("ROW") if self._match_text_seq("ROW") else self._parse_value(),
7412                        expression=self._match_text_seq("VALUES") and self._parse_value(),
7413                    )
7414            elif self._match(TokenType.UPDATE):
7415                expressions = self._parse_star()
7416                if expressions:
7417                    then = self.expression(exp.Update, expressions=expressions)
7418                else:
7419                    then = self.expression(
7420                        exp.Update,
7421                        expressions=self._match(TokenType.SET)
7422                        and self._parse_csv(self._parse_equality),
7423                    )
7424            elif self._match(TokenType.DELETE):
7425                then = self.expression(exp.Var, this=self._prev.text)
7426            else:
7427                then = self._parse_var_from_options(self.CONFLICT_ACTIONS)
7428
7429            whens.append(
7430                self.expression(
7431                    exp.When,
7432                    matched=matched,
7433                    source=source,
7434                    condition=condition,
7435                    then=then,
7436                )
7437            )
7438        return self.expression(exp.Whens, expressions=whens)
7439
7440    def _parse_show(self) -> t.Optional[exp.Expression]:
7441        parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE)
7442        if parser:
7443            return parser(self)
7444        return self._parse_as_command(self._prev)
7445
7446    def _parse_set_item_assignment(
7447        self, kind: t.Optional[str] = None
7448    ) -> t.Optional[exp.Expression]:
7449        index = self._index
7450
7451        if kind in ("GLOBAL", "SESSION") and self._match_text_seq("TRANSACTION"):
7452            return self._parse_set_transaction(global_=kind == "GLOBAL")
7453
7454        left = self._parse_primary() or self._parse_column()
7455        assignment_delimiter = self._match_texts(("=", "TO"))
7456
7457        if not left or (self.SET_REQUIRES_ASSIGNMENT_DELIMITER and not assignment_delimiter):
7458            self._retreat(index)
7459            return None
7460
7461        right = self._parse_statement() or self._parse_id_var()
7462        if isinstance(right, (exp.Column, exp.Identifier)):
7463            right = exp.var(right.name)
7464
7465        this = self.expression(exp.EQ, this=left, expression=right)
7466        return self.expression(exp.SetItem, this=this, kind=kind)
7467
7468    def _parse_set_transaction(self, global_: bool = False) -> exp.Expression:
7469        self._match_text_seq("TRANSACTION")
7470        characteristics = self._parse_csv(
7471            lambda: self._parse_var_from_options(self.TRANSACTION_CHARACTERISTICS)
7472        )
7473        return self.expression(
7474            exp.SetItem,
7475            expressions=characteristics,
7476            kind="TRANSACTION",
7477            **{"global": global_},  # type: ignore
7478        )
7479
7480    def _parse_set_item(self) -> t.Optional[exp.Expression]:
7481        parser = self._find_parser(self.SET_PARSERS, self.SET_TRIE)
7482        return parser(self) if parser else self._parse_set_item_assignment(kind=None)
7483
7484    def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
7485        index = self._index
7486        set_ = self.expression(
7487            exp.Set, expressions=self._parse_csv(self._parse_set_item), unset=unset, tag=tag
7488        )
7489
7490        if self._curr:
7491            self._retreat(index)
7492            return self._parse_as_command(self._prev)
7493
7494        return set_
7495
7496    def _parse_var_from_options(
7497        self, options: OPTIONS_TYPE, raise_unmatched: bool = True
7498    ) -> t.Optional[exp.Var]:
7499        start = self._curr
7500        if not start:
7501            return None
7502
7503        option = start.text.upper()
7504        continuations = options.get(option)
7505
7506        index = self._index
7507        self._advance()
7508        for keywords in continuations or []:
7509            if isinstance(keywords, str):
7510                keywords = (keywords,)
7511
7512            if self._match_text_seq(*keywords):
7513                option = f"{option} {' '.join(keywords)}"
7514                break
7515        else:
7516            if continuations or continuations is None:
7517                if raise_unmatched:
7518                    self.raise_error(f"Unknown option {option}")
7519
7520                self._retreat(index)
7521                return None
7522
7523        return exp.var(option)
7524
7525    def _parse_as_command(self, start: Token) -> exp.Command:
7526        while self._curr:
7527            self._advance()
7528        text = self._find_sql(start, self._prev)
7529        size = len(start.text)
7530        self._warn_unsupported()
7531        return exp.Command(this=text[:size], expression=text[size:])
7532
7533    def _parse_dict_property(self, this: str) -> exp.DictProperty:
7534        settings = []
7535
7536        self._match_l_paren()
7537        kind = self._parse_id_var()
7538
7539        if self._match(TokenType.L_PAREN):
7540            while True:
7541                key = self._parse_id_var()
7542                value = self._parse_primary()
7543                if not key and value is None:
7544                    break
7545                settings.append(self.expression(exp.DictSubProperty, this=key, value=value))
7546            self._match(TokenType.R_PAREN)
7547
7548        self._match_r_paren()
7549
7550        return self.expression(
7551            exp.DictProperty,
7552            this=this,
7553            kind=kind.this if kind else None,
7554            settings=settings,
7555        )
7556
7557    def _parse_dict_range(self, this: str) -> exp.DictRange:
7558        self._match_l_paren()
7559        has_min = self._match_text_seq("MIN")
7560        if has_min:
7561            min = self._parse_var() or self._parse_primary()
7562            self._match_text_seq("MAX")
7563            max = self._parse_var() or self._parse_primary()
7564        else:
7565            max = self._parse_var() or self._parse_primary()
7566            min = exp.Literal.number(0)
7567        self._match_r_paren()
7568        return self.expression(exp.DictRange, this=this, min=min, max=max)
7569
7570    def _parse_comprehension(
7571        self, this: t.Optional[exp.Expression]
7572    ) -> t.Optional[exp.Comprehension]:
7573        index = self._index
7574        expression = self._parse_column()
7575        if not self._match(TokenType.IN):
7576            self._retreat(index - 1)
7577            return None
7578        iterator = self._parse_column()
7579        condition = self._parse_assignment() if self._match_text_seq("IF") else None
7580        return self.expression(
7581            exp.Comprehension,
7582            this=this,
7583            expression=expression,
7584            iterator=iterator,
7585            condition=condition,
7586        )
7587
7588    def _parse_heredoc(self) -> t.Optional[exp.Heredoc]:
7589        if self._match(TokenType.HEREDOC_STRING):
7590            return self.expression(exp.Heredoc, this=self._prev.text)
7591
7592        if not self._match_text_seq("$"):
7593            return None
7594
7595        tags = ["$"]
7596        tag_text = None
7597
7598        if self._is_connected():
7599            self._advance()
7600            tags.append(self._prev.text.upper())
7601        else:
7602            self.raise_error("No closing $ found")
7603
7604        if tags[-1] != "$":
7605            if self._is_connected() and self._match_text_seq("$"):
7606                tag_text = tags[-1]
7607                tags.append("$")
7608            else:
7609                self.raise_error("No closing $ found")
7610
7611        heredoc_start = self._curr
7612
7613        while self._curr:
7614            if self._match_text_seq(*tags, advance=False):
7615                this = self._find_sql(heredoc_start, self._prev)
7616                self._advance(len(tags))
7617                return self.expression(exp.Heredoc, this=this, tag=tag_text)
7618
7619            self._advance()
7620
7621        self.raise_error(f"No closing {''.join(tags)} found")
7622        return None
7623
7624    def _find_parser(
7625        self, parsers: t.Dict[str, t.Callable], trie: t.Dict
7626    ) -> t.Optional[t.Callable]:
7627        if not self._curr:
7628            return None
7629
7630        index = self._index
7631        this = []
7632        while True:
7633            # The current token might be multiple words
7634            curr = self._curr.text.upper()
7635            key = curr.split(" ")
7636            this.append(curr)
7637
7638            self._advance()
7639            result, trie = in_trie(trie, key)
7640            if result == TrieResult.FAILED:
7641                break
7642
7643            if result == TrieResult.EXISTS:
7644                subparser = parsers[" ".join(this)]
7645                return subparser
7646
7647        self._retreat(index)
7648        return None
7649
7650    def _match(self, token_type, advance=True, expression=None):
7651        if not self._curr:
7652            return None
7653
7654        if self._curr.token_type == token_type:
7655            if advance:
7656                self._advance()
7657            self._add_comments(expression)
7658            return True
7659
7660        return None
7661
7662    def _match_set(self, types, advance=True):
7663        if not self._curr:
7664            return None
7665
7666        if self._curr.token_type in types:
7667            if advance:
7668                self._advance()
7669            return True
7670
7671        return None
7672
7673    def _match_pair(self, token_type_a, token_type_b, advance=True):
7674        if not self._curr or not self._next:
7675            return None
7676
7677        if self._curr.token_type == token_type_a and self._next.token_type == token_type_b:
7678            if advance:
7679                self._advance(2)
7680            return True
7681
7682        return None
7683
7684    def _match_l_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
7685        if not self._match(TokenType.L_PAREN, expression=expression):
7686            self.raise_error("Expecting (")
7687
7688    def _match_r_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
7689        if not self._match(TokenType.R_PAREN, expression=expression):
7690            self.raise_error("Expecting )")
7691
7692    def _match_texts(self, texts, advance=True):
7693        if (
7694            self._curr
7695            and self._curr.token_type != TokenType.STRING
7696            and self._curr.text.upper() in texts
7697        ):
7698            if advance:
7699                self._advance()
7700            return True
7701        return None
7702
7703    def _match_text_seq(self, *texts, advance=True):
7704        index = self._index
7705        for text in texts:
7706            if (
7707                self._curr
7708                and self._curr.token_type != TokenType.STRING
7709                and self._curr.text.upper() == text
7710            ):
7711                self._advance()
7712            else:
7713                self._retreat(index)
7714                return None
7715
7716        if not advance:
7717            self._retreat(index)
7718
7719        return True
7720
7721    def _replace_lambda(
7722        self, node: t.Optional[exp.Expression], expressions: t.List[exp.Expression]
7723    ) -> t.Optional[exp.Expression]:
7724        if not node:
7725            return node
7726
7727        lambda_types = {e.name: e.args.get("to") or False for e in expressions}
7728
7729        for column in node.find_all(exp.Column):
7730            typ = lambda_types.get(column.parts[0].name)
7731            if typ is not None:
7732                dot_or_id = column.to_dot() if column.table else column.this
7733
7734                if typ:
7735                    dot_or_id = self.expression(
7736                        exp.Cast,
7737                        this=dot_or_id,
7738                        to=typ,
7739                    )
7740
7741                parent = column.parent
7742
7743                while isinstance(parent, exp.Dot):
7744                    if not isinstance(parent.parent, exp.Dot):
7745                        parent.replace(dot_or_id)
7746                        break
7747                    parent = parent.parent
7748                else:
7749                    if column is node:
7750                        node = dot_or_id
7751                    else:
7752                        column.replace(dot_or_id)
7753        return node
7754
7755    def _parse_truncate_table(self) -> t.Optional[exp.TruncateTable] | exp.Expression:
7756        start = self._prev
7757
7758        # Not to be confused with TRUNCATE(number, decimals) function call
7759        if self._match(TokenType.L_PAREN):
7760            self._retreat(self._index - 2)
7761            return self._parse_function()
7762
7763        # Clickhouse supports TRUNCATE DATABASE as well
7764        is_database = self._match(TokenType.DATABASE)
7765
7766        self._match(TokenType.TABLE)
7767
7768        exists = self._parse_exists(not_=False)
7769
7770        expressions = self._parse_csv(
7771            lambda: self._parse_table(schema=True, is_db_reference=is_database)
7772        )
7773
7774        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
7775
7776        if self._match_text_seq("RESTART", "IDENTITY"):
7777            identity = "RESTART"
7778        elif self._match_text_seq("CONTINUE", "IDENTITY"):
7779            identity = "CONTINUE"
7780        else:
7781            identity = None
7782
7783        if self._match_text_seq("CASCADE") or self._match_text_seq("RESTRICT"):
7784            option = self._prev.text
7785        else:
7786            option = None
7787
7788        partition = self._parse_partition()
7789
7790        # Fallback case
7791        if self._curr:
7792            return self._parse_as_command(start)
7793
7794        return self.expression(
7795            exp.TruncateTable,
7796            expressions=expressions,
7797            is_database=is_database,
7798            exists=exists,
7799            cluster=cluster,
7800            identity=identity,
7801            option=option,
7802            partition=partition,
7803        )
7804
7805    def _parse_with_operator(self) -> t.Optional[exp.Expression]:
7806        this = self._parse_ordered(self._parse_opclass)
7807
7808        if not self._match(TokenType.WITH):
7809            return this
7810
7811        op = self._parse_var(any_token=True)
7812
7813        return self.expression(exp.WithOperator, this=this, op=op)
7814
7815    def _parse_wrapped_options(self) -> t.List[t.Optional[exp.Expression]]:
7816        self._match(TokenType.EQ)
7817        self._match(TokenType.L_PAREN)
7818
7819        opts: t.List[t.Optional[exp.Expression]] = []
7820        while self._curr and not self._match(TokenType.R_PAREN):
7821            if self._match_text_seq("FORMAT_NAME", "="):
7822                # The FORMAT_NAME can be set to an identifier for Snowflake and T-SQL,
7823                # so we parse it separately to use _parse_field()
7824                prop = self.expression(
7825                    exp.Property, this=exp.var("FORMAT_NAME"), value=self._parse_field()
7826                )
7827                opts.append(prop)
7828            else:
7829                opts.append(self._parse_property())
7830
7831            self._match(TokenType.COMMA)
7832
7833        return opts
7834
7835    def _parse_copy_parameters(self) -> t.List[exp.CopyParameter]:
7836        sep = TokenType.COMMA if self.dialect.COPY_PARAMS_ARE_CSV else None
7837
7838        options = []
7839        while self._curr and not self._match(TokenType.R_PAREN, advance=False):
7840            option = self._parse_var(any_token=True)
7841            prev = self._prev.text.upper()
7842
7843            # Different dialects might separate options and values by white space, "=" and "AS"
7844            self._match(TokenType.EQ)
7845            self._match(TokenType.ALIAS)
7846
7847            param = self.expression(exp.CopyParameter, this=option)
7848
7849            if prev in self.COPY_INTO_VARLEN_OPTIONS and self._match(
7850                TokenType.L_PAREN, advance=False
7851            ):
7852                # Snowflake FILE_FORMAT case, Databricks COPY & FORMAT options
7853                param.set("expressions", self._parse_wrapped_options())
7854            elif prev == "FILE_FORMAT":
7855                # T-SQL's external file format case
7856                param.set("expression", self._parse_field())
7857            else:
7858                param.set("expression", self._parse_unquoted_field())
7859
7860            options.append(param)
7861            self._match(sep)
7862
7863        return options
7864
7865    def _parse_credentials(self) -> t.Optional[exp.Credentials]:
7866        expr = self.expression(exp.Credentials)
7867
7868        if self._match_text_seq("STORAGE_INTEGRATION", "="):
7869            expr.set("storage", self._parse_field())
7870        if self._match_text_seq("CREDENTIALS"):
7871            # Snowflake case: CREDENTIALS = (...), Redshift case: CREDENTIALS <string>
7872            creds = (
7873                self._parse_wrapped_options() if self._match(TokenType.EQ) else self._parse_field()
7874            )
7875            expr.set("credentials", creds)
7876        if self._match_text_seq("ENCRYPTION"):
7877            expr.set("encryption", self._parse_wrapped_options())
7878        if self._match_text_seq("IAM_ROLE"):
7879            expr.set("iam_role", self._parse_field())
7880        if self._match_text_seq("REGION"):
7881            expr.set("region", self._parse_field())
7882
7883        return expr
7884
7885    def _parse_file_location(self) -> t.Optional[exp.Expression]:
7886        return self._parse_field()
7887
7888    def _parse_copy(self) -> exp.Copy | exp.Command:
7889        start = self._prev
7890
7891        self._match(TokenType.INTO)
7892
7893        this = (
7894            self._parse_select(nested=True, parse_subquery_alias=False)
7895            if self._match(TokenType.L_PAREN, advance=False)
7896            else self._parse_table(schema=True)
7897        )
7898
7899        kind = self._match(TokenType.FROM) or not self._match_text_seq("TO")
7900
7901        files = self._parse_csv(self._parse_file_location)
7902        credentials = self._parse_credentials()
7903
7904        self._match_text_seq("WITH")
7905
7906        params = self._parse_wrapped(self._parse_copy_parameters, optional=True)
7907
7908        # Fallback case
7909        if self._curr:
7910            return self._parse_as_command(start)
7911
7912        return self.expression(
7913            exp.Copy,
7914            this=this,
7915            kind=kind,
7916            credentials=credentials,
7917            files=files,
7918            params=params,
7919        )
7920
7921    def _parse_normalize(self) -> exp.Normalize:
7922        return self.expression(
7923            exp.Normalize,
7924            this=self._parse_bitwise(),
7925            form=self._match(TokenType.COMMA) and self._parse_var(),
7926        )
7927
7928    def _parse_ceil_floor(self, expr_type: t.Type[TCeilFloor]) -> TCeilFloor:
7929        args = self._parse_csv(lambda: self._parse_lambda())
7930
7931        this = seq_get(args, 0)
7932        decimals = seq_get(args, 1)
7933
7934        return expr_type(
7935            this=this, decimals=decimals, to=self._match_text_seq("TO") and self._parse_var()
7936        )
7937
7938    def _parse_star_ops(self) -> t.Optional[exp.Expression]:
7939        if self._match_text_seq("COLUMNS", "(", advance=False):
7940            this = self._parse_function()
7941            if isinstance(this, exp.Columns):
7942                this.set("unpack", True)
7943            return this
7944
7945        return self.expression(
7946            exp.Star,
7947            **{  # type: ignore
7948                "except": self._parse_star_op("EXCEPT", "EXCLUDE"),
7949                "replace": self._parse_star_op("REPLACE"),
7950                "rename": self._parse_star_op("RENAME"),
7951            },
7952        )
7953
7954    def _parse_grant_privilege(self) -> t.Optional[exp.GrantPrivilege]:
7955        privilege_parts = []
7956
7957        # Keep consuming consecutive keywords until comma (end of this privilege) or ON
7958        # (end of privilege list) or L_PAREN (start of column list) are met
7959        while self._curr and not self._match_set(self.PRIVILEGE_FOLLOW_TOKENS, advance=False):
7960            privilege_parts.append(self._curr.text.upper())
7961            self._advance()
7962
7963        this = exp.var(" ".join(privilege_parts))
7964        expressions = (
7965            self._parse_wrapped_csv(self._parse_column)
7966            if self._match(TokenType.L_PAREN, advance=False)
7967            else None
7968        )
7969
7970        return self.expression(exp.GrantPrivilege, this=this, expressions=expressions)
7971
7972    def _parse_grant_principal(self) -> t.Optional[exp.GrantPrincipal]:
7973        kind = self._match_texts(("ROLE", "GROUP")) and self._prev.text.upper()
7974        principal = self._parse_id_var()
7975
7976        if not principal:
7977            return None
7978
7979        return self.expression(exp.GrantPrincipal, this=principal, kind=kind)
7980
7981    def _parse_grant(self) -> exp.Grant | exp.Command:
7982        start = self._prev
7983
7984        privileges = self._parse_csv(self._parse_grant_privilege)
7985
7986        self._match(TokenType.ON)
7987        kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
7988
7989        # Attempt to parse the securable e.g. MySQL allows names
7990        # such as "foo.*", "*.*" which are not easily parseable yet
7991        securable = self._try_parse(self._parse_table_parts)
7992
7993        if not securable or not self._match_text_seq("TO"):
7994            return self._parse_as_command(start)
7995
7996        principals = self._parse_csv(self._parse_grant_principal)
7997
7998        grant_option = self._match_text_seq("WITH", "GRANT", "OPTION")
7999
8000        if self._curr:
8001            return self._parse_as_command(start)
8002
8003        return self.expression(
8004            exp.Grant,
8005            privileges=privileges,
8006            kind=kind,
8007            securable=securable,
8008            principals=principals,
8009            grant_option=grant_option,
8010        )
8011
8012    def _parse_overlay(self) -> exp.Overlay:
8013        return self.expression(
8014            exp.Overlay,
8015            **{  # type: ignore
8016                "this": self._parse_bitwise(),
8017                "expression": self._match_text_seq("PLACING") and self._parse_bitwise(),
8018                "from": self._match_text_seq("FROM") and self._parse_bitwise(),
8019                "for": self._match_text_seq("FOR") and self._parse_bitwise(),
8020            },
8021        )